Changeset 4f66cc7b – HelenOS

dist/Makefile

-              r45dd8bf
+              r4f66cc7b
 SUFFIX = $(suffix $(IMGFILE))
+DISTFILE = HelenOS-$(RELEASE)-$(PLATFORM)-$(MACHINE)-$(PROCESSOR)$(SUFFIX)
+ifdef PROFILE
+        DISTFILE = Helenos-$(shell echo $(PROFILE) | tr '/' '-')$(SUFFIX)
+else
+        DISTFILE = HelenOS-$(RELEASE)-$(PLATFORM)-$(MACHINE)-$(PROCESSOR)$(SUFFIX)
+endif
 .PHONY: all clean dist distfile
 …
         cp $< $@
+$(IMGFILE):
+        $(MAKE) -C ..
 dist:
         for profile in $(PROFILES); do \

uspace/app/usbinfo/info.c

-              r45dd8bf
+              r4f66cc7b
                 goto leave;
+        }
+        rc = usb_endpoint_pipe_probe_default_control(&ctrl_pipe);
+        if (rc != EOK) {
+                fprintf(stderr,
+                    NAME ": probing default control pipe failed: %s.\n",
+                    str_error(rc));
+                goto leave;
+        }
         rc = usb_endpoint_pipe_start_session(&ctrl_pipe);
         if (rc != EOK) {

uspace/app/usbinfo/main.c

r45dd8bf	r4f66cc7b
82	82
83	83	if (str_cmp(path, "uhci") == 0) {
84		path = "/hw/pci0/00:01.2/uhci";
	84	path = "/hw/pci0/00:01.2/uhci-hc";
85	85	}
86	86

uspace/doc/doxygroups.h

-              r45dd8bf
+              r4f66cc7b
          * @defgroup drvusbuhci UHCI driver
          * @ingroup usb
+         * @brief Driver for USB host controller UHCI.
+         */
+         * @brief Drivers for USB UHCI host controller and root hub.
+         */
+                /**
+                 * @defgroup drvusbuhcirh UHCI root hub driver
+                 * @ingroup drvusbuhci
+                 * @brief Driver for UHCI complaint root hub.
+                 */
+                /**
+                 * @defgroup drvusbuhcihc UHCI host controller driver
+                 * @ingroup drvusbuhci
+                 * @brief Driver for UHCI complaint USB host controller.
+                 */
         /**

uspace/drv/ehci-hcd/main.c

r45dd8bf	r4f66cc7b
27	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	28	*/
29		/** @addtogroup ~~usbdrv~~ehci
	29	/** @addtogroup drvusbehci
30	30	* @{
31	31	*/

uspace/drv/ehci-hcd/pci.c

-              r45dd8bf
+              r4f66cc7b
         if ((value & USBLEGSUP_BIOS_CONTROL) != 0) {
+        if ((value & USBLEGSUP_BIOS_CONTROL) == 0) {
                 usb_log_info("BIOS released control after %d usec.\n", wait);
         } else {
                 /* BIOS failed to hand over control, this should not happen. */
                 usb_log_warning( "BIOS failed to release control after"
+                usb_log_warning( "BIOS failed to release control after "
                     "%d usecs, force it.\n", wait);
                 ret = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
 …
                 CHECK_RET_HANGUP_RETURN(ret,
                     "Failed(%d) to force OS EHCI control.\n", ret);
-                /* TODO: This does not seem to work on my machine */
+        }
 …
         usb_log_debug2("USBLEGSUP: %x.\n", value);
 /*
+ * TURN OFF EHCI FOR NOW, REMOVE IF THE DRIVER IS IMPLEMENTED
  */
+        /*
+         * TURN OFF EHCI FOR NOW, DRIVER WILL REINITIALIZE IT
+         */
         /* Get size of capability registers in memory space. */

uspace/drv/pciintel/pci.c

-              r45dd8bf
+              r4f66cc7b
         pci_fun_t *dev_data = (pci_fun_t *) fnode->driver_data;
   sysarg_t apic;
   sysarg_t i8259;
+        sysarg_t apic;
+        sysarg_t i8259;
         int irc_phone = -1;
         int irc_service = 0;
   if ((sysinfo_get_value("apic", &apic) == EOK) && (apic)) {
     irc_service = SERVICE_APIC;
+        int irc_service = -1;
+        if ((sysinfo_get_value("apic", &apic) == EOK) && (apic)) {
+                irc_service = SERVICE_APIC;
         } else if ((sysinfo_get_value("i8259", &i8259) == EOK) && (i8259)) {
     irc_service = SERVICE_I8259;
+        }
+  if (irc_service == 0)
+                irc_service = SERVICE_I8259;
+        }
+        if (irc_service == -1) {
                 return false;
+        }
         irc_phone = service_connect_blocking(irc_service, 0, 0);
         if (irc_phone < 0)
+        if (irc_phone < 0) {
                 return false;
+        }
         size_t i;
   for (i = 0; i < dev_data->hw_resources.count; i++) {
+        for (i = 0; i < dev_data->hw_resources.count; i++) {
                 if (dev_data->hw_resources.resources[i].type == INTERRUPT) {
                         int irq = dev_data->hw_resources.resources[i].res.interrupt.irq;

uspace/drv/uhci-hcd/Makefile

-              r45dd8bf
+              r4f66cc7b
         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

-              r45dd8bf
+              r4f66cc7b
  * 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,
 …
 static void batch_call_in_and_dispose(batch_t *instance);
 static void batch_call_out_and_dispose(batch_t *instance);
+static void batch_dispose(batch_t *instance);
+/** Allocates memory and initializes internal data structures.
+/** Allocate memory and initialize internal data structure.
+ *
  * @param[in] fun DDF function to pass to callback.
 …
  * @param[in] arg additional parameter to func_in or func_out
  * @param[in] manager Pointer to toggle management structure.
+ * @return False, if there is an active TD, true otherwise.
+ * @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,
 …
         bzero(instance, sizeof(batch_t));
         instance->qh = malloc32(sizeof(queue_head_t));
+        instance->qh = malloc32(sizeof(qh_t));
         CHECK_NULL_DISPOSE_RETURN(instance->qh,
             "Failed to allocate batch queue head.\n");
         queue_head_init(instance->qh);
+        qh_init(instance->qh);
         instance->packets = (size + max_packet_size - 1) / max_packet_size;
 …
             instance->tds, "Failed to allocate transfer descriptors.\n");
         bzero(instance->tds, sizeof(td_t) * instance->packets);
-//      const size_t transport_size = max_packet_size * instance->packets;
         if (size > 0) {
 …
         instance->speed = speed;
         instance->manager = manager;
+        if (func_out)
+                instance->callback_out = func_out;
+        if (func_in)
+                instance->callback_in = func_in;
+        queue_head_set_element_td(instance->qh, addr_to_phys(instance->tds));
+        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",
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Checks batch TDs for activity.
+/** 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)
 …
                         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,
 …
+ *
  * @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 */
+        /* We are data out, we are supposed to provide data */
         memcpy(instance->transport_buffer, instance->buffer,
             instance->buffer_size);
 …
         instance->next_step = batch_call_out_and_dispose;
         usb_log_debug("Batch(%p) CONTROL WRITE initialized.\n", instance);
-        batch_schedule(instance);
+}
 /*----------------------------------------------------------------------------*/
 …
+ *
  * @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);
+}
+/*----------------------------------------------------------------------------*/
+/** Prepares interrupt in transaction.
+ *
+ * @param[in] instance Batch structure to use.
+}
+/*----------------------------------------------------------------------------*/
+/** Prepare interrupt in transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transaction with PID_IN.
  */
 void batch_interrupt_in(batch_t *instance)
 …
         instance->next_step = batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) INTERRUPT IN initialized.\n", instance);
+        batch_schedule(instance);
+}
+/*----------------------------------------------------------------------------*/
+/** Prepares interrupt out transaction.
+ *
+ * @param[in] instance Batch structure to use.
+}
+/*----------------------------------------------------------------------------*/
+/** 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 */
+        /* 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) INTERRUPT OUT initialized.\n", instance);
+        batch_schedule(instance);
+}
+/*----------------------------------------------------------------------------*/
+/** Prepares bulk in transaction.
+ *
+ * @param[in] instance Batch structure to use.
+}
+/*----------------------------------------------------------------------------*/
+/** Prepare bulk in transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ *
+ * Data transaction with PID_IN.
  */
 void batch_bulk_in(batch_t *instance)
 …
         instance->next_step = batch_call_in_and_dispose;
         usb_log_debug("Batch(%p) BULK IN initialized.\n", instance);
+        batch_schedule(instance);
+}
+/*----------------------------------------------------------------------------*/
+/** Prepares bulk out transaction.
+ *
+ * @param[in] instance Batch structure to use.
+}
+/*----------------------------------------------------------------------------*/
+/** 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);
+        batch_schedule(instance);
+}
+/*----------------------------------------------------------------------------*/
+/** Prepares generic data transaction
+}
+/*----------------------------------------------------------------------------*/
+/** 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)
 …
                 ++packet;
+        }
+        td_set_ioc(&instance->tds[packet - 1]);
         device_keeper_set_toggle(instance->manager, instance->target, toggle);
+}
 /*----------------------------------------------------------------------------*/
 /** Prepares generic control transaction
+/** 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,
 …
 , 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);
+}
 /*----------------------------------------------------------------------------*/
+/** Prepares data, gets error status and calls callback in.
+ *
+ * @param[in] instance Batch structure to use.
+/** 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);
         /* we are data in, we need data */
+        /* We are data in, we need data */
         memcpy(instance->buffer, instance->transport_buffer,
             instance->buffer_size);
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Gets error status and calls callback out.
+/** Get error status and call callback out.
+ *
  * @param[in] instance Batch structure to use.
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Prepares data, gets error status, calls callback in and dispose.
+/** Helper function calls callback and correctly disposes of batch structure.
+ *
  * @param[in] instance Batch structure to use.
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Gets error status, calls callback out and dispose.
+/** Helper function calls callback and correctly disposes of batch structure.
+ *
  * @param[in] instance Batch structure to use.
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Correctly disposes all used data structures.
+/** Correctly dispose all used data structures.
+ *
  * @param[in] instance Batch structure to use.
 …
         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

-              r45dd8bf
+              r4f66cc7b
  * 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
 …
         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;
+        qh_t *qh;
         td_t *tds;
         void (*next_step)(struct batch*);
 …
                 device_keeper_t *manager
                 );
+void batch_dispose(batch_t *instance);
 bool batch_is_complete(batch_t *instance);

uspace/drv/uhci-hcd/iface.c

-              r45dd8bf
+              r4f66cc7b
  * 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"
 …
+{
         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);
 …
+{
         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");
 …
+{
         assert(fun);
         uhci_t *hc = fun_to_uhci(fun);
+        uhci_hc_t *hc = fun_to_uhci_hc(fun);
         assert(hc);
         assert(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 bind %d-%d.\n", address, 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 release %d.\n", address);
 …
+{
         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);
 …
                 return ENOMEM;
         batch_interrupt_out(batch);
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
         return EOK;
+}
 …
+{
         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);
 …
                 return ENOMEM;
         batch_interrupt_in(batch);
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
         return EOK;
+}
 …
+{
         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);
 …
                 return ENOMEM;
         batch_bulk_out(batch);
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
         return EOK;
+}
 …
+{
         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);
 …
                 return ENOMEM;
         batch_bulk_in(batch);
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
         return EOK;
+}
 …
+{
         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)
 …
         device_keeper_reset_if_need(&hc->device_manager, target, setup_data);
         batch_control_write(batch);
+        const int ret = uhci_hc_schedule(hc, batch);
+        if (ret != EOK) {
+                batch_dispose(batch);
+                return ret;
+        }
         return EOK;
+}
 …
+{
         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,
 …
                 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,

uspace/drv/uhci-hcd/iface.h

-              r45dd8bf
+              r4f66cc7b
  */
 /** @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

-              r45dd8bf
+              r4f66cc7b
  * 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"
 …
 };
 /*----------------------------------------------------------------------------*/
+/** IRQ handling callback, identifies devic
+ *
+ * @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_t *hc = dev_to_uhci(dev);
+        uint16_t status = IPC_GET_ARG1(*call);
+        assert(hc);
+        uhci_interrupt(hc, status);
+}
+/*----------------------------------------------------------------------------*/
+/** Initializes a new ddf driver instance of UHCI hcd.
+/** Initialize a new ddf driver instance for uhci hc and hub.
+ *
  * @param[in] device DDF instance of the device to initialize.
  * @return Error code.
+ *
- * Gets and initialies hardware resources, disables any legacy support,
- * and reports root hub device.
  */
 int uhci_add_device(ddf_dev_t *device)
+{
+        usb_log_info("uhci_add_device() called\n");
         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; \
+}
+        uhci_t *uhci = malloc(sizeof(uhci_t));
+        if (uhci == NULL) {
+                usb_log_error("Failed to allocate UHCI driver.\n");
+                return ENOMEM;
+        }
+        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) to disable legacy USB: %s.\n", ret, str_error(ret));
+#if 0
+        ret = pci_enable_interrupts(device);
+        int ret = uhci_init(uhci, device);
         if (ret != EOK) {
+                usb_log_warning(
+                    "Failed(%d) to enable interrupts, fall back to polling.\n",
+                    ret);
+                usb_log_error("Failed to initialzie UHCI driver.\n");
+                return 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);
+        device->driver_data = uhci;
         return EOK;
-#undef CHECK_RET_FINI_FREE_RETURN
+}
 /*----------------------------------------------------------------------------*/
 /** Initializes global driver structures (NONE).
+/** Initialize global driver structures (NONE).
+ *
  * @param[in] argc Nmber of arguments in argv vector (ignored).
 …
 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

-              r45dd8bf
+              r4f66cc7b
  */
 /**
  * @addtogroup drvusbuhci
+ * @addtogroup drvusbuhcihc
  * @{
  */
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Calls the PCI driver with a request to enable interrupts
+/** Call the PCI driver with a request to enable interrupts
+ *
  * @param[in] device Device asking for interrupts
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Calls the PCI driver with a request to clear legacy support register
+/** Call the PCI driver with a request to clear legacy support register
+ *
  * @param[in] device Device asking to disable interrupts

uspace/drv/uhci-hcd/pci.h

-              r45dd8bf
+              r4f66cc7b
  */
 /** @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

-              r45dd8bf
+              r4f66cc7b
  * 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>
 …
     transfer_list_t *instance, batch_t *batch);
 /*----------------------------------------------------------------------------*/
 /** Initializes transfer list structures.
+/** Initialize transfer list structures.
+ *
  * @param[in] instance Memory place to use.
  * @param[in] name Name of te new list.
  * @return Error code
+ *
  * Allocates memory for internat queue_head_t structure.
+ * @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 = malloc32(sizeof(queue_head_t));
+        instance->queue_head = malloc32(sizeof(qh_t));
         if (!instance->queue_head) {
                 usb_log_error("Failed to allocate queue head.\n");
 …
         instance->queue_head_pa = addr_to_phys(instance->queue_head);
         queue_head_init(instance->queue_head);
+        qh_init(instance->queue_head);
         list_initialize(&instance->batch_list);
         fibril_mutex_initialize(&instance->guard);
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Set the next list in chain.
+/** 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;
+}
+/*----------------------------------------------------------------------------*/
+/** Submits a new transfer batch to list and 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",
+            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);
+}
 /*----------------------------------------------------------------------------*/
 /** Removes a transfer batch from list and queue.
+/** 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(batch->qh);
         usb_log_debug2(
+            "Removing batch(%p) from queue %s.\n", batch, instance->name);
+            "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) {
                 /* I'm the first one here */
+                usb_log_debug(
+                    "Batch(%p) removed (FIRST) from %s, next element %x.\n",
+                    batch, instance->name, batch->qh->next_queue);
+                instance->queue_head->element = batch->qh->next_queue;
+                qh_set_element_qh(instance->queue_head, batch->qh->next);
+                pos = "FIRST";
         } else {
-                usb_log_debug(
-                    "Batch(%p) removed (FIRST:NO) from %s, 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;
+        }
+                qh_set_next_qh(prev->qh, batch->qh->next);
+                pos = "NOT FIRST";
+        }
+        /* Remove from the driver list */
         list_remove(&batch->link);
+}
+/*----------------------------------------------------------------------------*/
+/** Checks list for finished transfers.
+        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

-              r45dd8bf
+              r4f66cc7b
  * 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);
-        free32(instance->queue_head);
+}
 void transfer_list_remove_finished(transfer_list_t *instance);

uspace/drv/uhci-hcd/uhci.c

-              r45dd8bf
+              r4f66cc7b
  * 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
+        }
 };
 /** Gets USB address of the calling device.
+ *
  * @param[in] fun UHCI hc function.
  * @param[in] handle Handle of the device seeking address.
  * @param[out] address Place to store found address.
  * @return Error code.
+#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(
 …
+{
         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 transfer, size_t size);
+/*----------------------------------------------------------------------------*/
+/** Initializes UHCI hcd driver structure
+ *
+ * @param[in] instance Memory place to initialize.
+ * @param[in] dev DDF device.
+ * @param[in] regs Address of I/O control registers.
+ * @param[in] size Size of I/O control registers.
+ * @return Error code.
+ * @note Should be called only once on any structure.
+ */
+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
+}
+/*----------------------------------------------------------------------------*/
+/** Initializes UHCI hcd hw resources.
+ *
+ * @param[in] instance UHCI structure to use.
+ */
+void uhci_init_hw(uhci_t *instance)
+{
+        assert(instance);
+        regs_t *registers = instance->registers;
+        /* Reset everything, who knows what touched it before us */
+        pio_write_16(&registers->usbcmd, UHCI_CMD_GLOBAL_RESET);
+        async_usleep(10000); /* 10ms according to USB spec */
+        pio_write_16(&registers->usbcmd, 0);
+        /* Reset hc, all states and counters */
+        pio_write_16(&registers->usbcmd, UHCI_CMD_HCRESET);
+        do { async_usleep(10); }
+        while ((pio_read_16(&registers->usbcmd) & UHCI_CMD_HCRESET) != 0);
+        /* Set framelist pointer */
+        const uint32_t pa = addr_to_phys(instance->frame_list);
+        pio_write_32(&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);
+        uint16_t status = pio_read_16(&registers->usbcmd);
+        if (status != 0)
+                usb_log_warning("Previous command value: %x.\n", status);
+        /* Start the hc with large(64B) packet FSBR */
+        pio_write_16(&registers->usbcmd,
+            UHCI_CMD_RUN_STOP | UHCI_CMD_MAX_PACKET | UHCI_CMD_CONFIGURE);
+}
+/*----------------------------------------------------------------------------*/
+/** Initializes UHCI hcd memory structures.
+ *
+ * @param[in] instance UHCI structure to use.
+ * @return Error code
+ * @note Should be called only once on any structure.
+ */
+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 init transfer lists.\n");
+        usb_log_debug("Initialized transfer lists.\n");
+        /* Init USB frame list page*/
+        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");
+        /* Set 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 device keeper*/
+        device_keeper_init(&instance->device_manager);
+        usb_log_debug("Initialized device manager.\n");
+        return EOK;
+#undef CHECK_RET_DEST_CMDS_RETURN
+}
+/*----------------------------------------------------------------------------*/
+/** Initializes UHCI hcd transfer lists.
+ *
+ * @param[in] instance UHCI structure to use.
+ * @return Error code
+ * @note Should be called only once on any structure.
+ */
+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
+        /* Assign pointers to be used during scheduling */
+        instance->transfers[USB_SPEED_FULL][USB_TRANSFER_INTERRUPT] =
+          &instance->transfers_interrupt;
+        instance->transfers[USB_SPEED_LOW][USB_TRANSFER_INTERRUPT] =
+          &instance->transfers_interrupt;
+        instance->transfers[USB_SPEED_FULL][USB_TRANSFER_CONTROL] =
+          &instance->transfers_control_full;
+        instance->transfers[USB_SPEED_LOW][USB_TRANSFER_CONTROL] =
+          &instance->transfers_control_slow;
+        instance->transfers[USB_SPEED_FULL][USB_TRANSFER_BULK] =
+          &instance->transfers_bulk_full;
+        return EOK;
+#undef CHECK_RET_CLEAR_RETURN
+}
+/*----------------------------------------------------------------------------*/
+/** Schedules batch for execution.
+ *
+ * @param[in] instance UHCI structure to use.
+ * @param[in] batch Transfer batch to schedule.
+ * @return Error code
+ */
+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;
+}
+/*----------------------------------------------------------------------------*/
+/** Takes action based on the interrupt cause.
+ *
+ * @param[in] instance UHCI structure to use.
+ * @param[in] status Value of the stsatus regiser at the time of interrupt.
+ */
+void uhci_interrupt(uhci_t *instance, uint16_t status)
+{
+        assert(instance);
+        /* TODO: Check interrupt cause here */
+        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);
+}
+/*----------------------------------------------------------------------------*/
+/** Polling function, emulates interrupts.
+ *
+ * @param[in] arg UHCI structure to use.
+ * @return EOK
+ */
+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);
+        }
+        return EOK;
+}
+/*---------------------------------------------------------------------------*/
+/** Debug function, checks consistency of memory structures.
+ *
+ * @param[in] arg UHCI structure to use.
+ * @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 EOK;
+#undef QH
+}
+/*----------------------------------------------------------------------------*/
+/** Checks transfer packets, for USB validity
+ *
+ * @param[in] low_speed Transfer speed.
+ * @param[in] transfer Transer type
+ * @param[in] size Maximum size of used packets
+ * @return EOK
+ */
+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

-              r45dd8bf
+              r4f66cc7b
 /*
  * 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;
+        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

-              r45dd8bf
+              r4f66cc7b
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhci
  * @{
  */
 …
  */
 #include <assert.h>
+#include <errno.h>
+#include <str_error.h>
 #include <stdio.h>
 #include <usb/debug.h>
+#include "port_status.h"
+#include "uhci_rh.h"
+#include "uhci_hc.h"
+struct flag_name
+{
+        uint16_t flag;
+        const char *name;
+};
+static const struct flag_name flags[] =
+{
+        { STATUS_SUSPEND, "suspended" },
+        { STATUS_IN_RESET, "in reset" },
+        { STATUS_LOW_SPEED, "low speed device" },
+        { STATUS_ALWAYS_ONE, "always 1 bit" },
+        { STATUS_RESUME, "resume" },
+        { STATUS_LINE_D_MINUS, "line D- value" },
+        { STATUS_LINE_D_PLUS, "line D+ value" },
+        { STATUS_ENABLED_CHANGED, "enabled changed" },
+        { STATUS_ENABLED, "enabled" },
+        { STATUS_CONNECTED_CHANGED, "connected changed" },
+        { STATUS_CONNECTED, "connected" }
+};
+/** Prints portr status in a human readable way.
+ *
+ * @param[in] value Port value to print.
+/** 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.
  */
+void print_port_status(port_status_t value)
+int uhci_rh_init(
+    uhci_rh_t *instance, ddf_fun_t *fun, uintptr_t reg_addr, size_t reg_size)
+{
+        unsigned i = 0;
+        for (;i < sizeof(flags)/sizeof(struct flag_name); ++i) {
+                usb_log_debug2("\t%s status: %s.\n", flags[i].name,
+                  ((value & flags[i].flag) != 0) ? "YES" : "NO");
+        assert(fun);
+        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;
+        }
+        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;
+        }
+        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;
+        return EOK;
+}
 /**

uspace/drv/uhci-hcd/uhci_rh.h

-              r45dd8bf
+              r4f66cc7b
 /*
  * 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

-              r45dd8bf
+              r4f66cc7b
  * 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

-              r45dd8bf
+              r4f66cc7b
 /*
  * 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_set_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;
+        }
+}

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

-              r45dd8bf
+              r4f66cc7b
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcihc
  * @{
  */
 …
 #include "utils/malloc32.h"
 /** Initializes Transfer Descriptor
+/** Initialize Transfer Descriptor
+ *
  * @param[in] instance Memory place to initialize.
 …
  * @param[in] size Size of data source.
  * @param[in] toggle Value of toggle bit.
  * @param[in] iso True if TD is for Isochronous transfer.
+ * @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] 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,
 …
+        }
         usb_log_debug2("Created TD: %X:%X:%X:%X(%p).\n",
             instance->next, instance->status, instance->device,
+        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));
+                    usb_debug_str_buffer(buffer, 8, 8));
+        }
+}
 /*----------------------------------------------------------------------------*/
 /** Converts TD status into standard error code
+/** Convert TD status into standard error code
+ *
  * @param[in] instance TD structure to use.
 …
         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

-              r45dd8bf
+              r4f66cc7b
 /*
  * 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)) td_t;
 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);
+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 td_status(td_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);
+        return
+            ((instance->status >> TD_STATUS_ACTLEN_POS) + 1)
+            & TD_STATUS_ACTLEN_MASK;
+        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)
+{
 …
             (instance->status | TD_STATUS_SPD_FLAG) && act_size < max_size;
+}
+/*----------------------------------------------------------------------------*/
+/** 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) != 0)
+            ? 1 : 0;
+        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)
+{
 …
         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

-              r45dd8bf
+              r4f66cc7b
  */
 /** @addtogroup drvusbuhci
+/** @addtogroup drvusbuhcihc
  * @{
  */
 …
 /*----------------------------------------------------------------------------*/
 /** Initializes device keeper structure.
+/** 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)
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Attempts to obtain address 0, blocks.
+/** Attempt to obtain address 0, blocks.
+ *
  * @param[in] instance Device keeper structure to use.
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Attempts to obtain address 0, blocks.
+/** Attempt to obtain address 0, blocks.
+ *
  * @param[in] instance Device keeper structure to use.
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Checks setup data for signs of toggle reset.
+/** 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(
 …
             || !instance->devices[target.address].occupied) {
                 fibril_mutex_unlock(&instance->guard);
+                usb_log_error("Invalid data when checking for toggle reset.\n");
                 return;
+        }
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Gets current value of endpoint toggle.
+/** Get current value of endpoint toggle.
+ *
  * @param[in] instance Device keeper structure to use.
 …
             || 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
+                ret = (instance->devices[target.address].toggle_status
                         >> target.endpoint) & 1;
+        }
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Sets current value of endpoint toggle.
+/** Set current value of endpoint toggle.
+ *
  * @param[in] instance Device keeper structure to use.
  * @param[in] target Device and endpoint used.
  * @param[in] toggle Current toggle value.
+ * @param[in] toggle Toggle value.
  * @return Error code.
  */
 …
             || 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 {
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Gets a free USB address
+/** Get a free USB address
+ *
  * @param[in] instance Device keeper structure to use.
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Binds USB address to devman handle.
+/** Bind USB address to devman handle.
+ *
  * @param[in] instance Device keeper structure to use.
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Releases used USB address.
+/** Release used USB address.
+ *
  * @param[in] instance Device keeper structure to use.
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Finds USB address associated with the device
+/** Find USB address associated with the device
+ *
  * @param[in] instance Device keeper structure to use.
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Gets speed associated with the address
+/** Get speed associated with the address
+ *
  * @param[in] instance Device keeper structure to use.

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

r45dd8bf	r4f66cc7b
27	27	*/
28	28
29		/** @addtogroup drvusbuhci
	29	/** @addtogroup drvusbuhcihc
30	30	* @{
31	31	*/

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

-              r45dd8bf
+              r4f66cc7b
 #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

uspace/drv/uhci-rhd/Makefile

r45dd8bf	r4f66cc7b
35	35	main.c \
36	36	port.c \
37		~~port_status.c \~~
38	37	root_hub.c
39	38

uspace/drv/uhci-rhd/main.c

-              r45dd8bf
+              r4f66cc7b
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcirh
  * @{
  */
 /** @file
  * @brief UHCI driver
+ * @brief UHCI root hub initialization routines
  */
 #include <ddf/driver.h>
 …
 #include <usb/debug.h>
 #include "root_hub.h"
 …
 static int hc_get_my_registers(ddf_dev_t *dev,
     uintptr_t *io_reg_address, size_t *io_reg_size);
+#if 0
 /*----------------------------------------------------------------------------*/
 static int usb_iface_get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
 …
         .interfaces[USB_DEV_IFACE] = &uhci_rh_usb_iface,
 };
+#endif
 /*----------------------------------------------------------------------------*/
 /** Initializes a new ddf driver instance of UHCI root hub.
+/** Initialize a new ddf driver instance of UHCI root hub.
+ *
  * @param[in] device DDF instance of the device to initialize.
 …
         //device->ops = &uhci_rh_ops;
-        (void) uhci_rh_ops;
-        uhci_root_hub_t *rh = malloc(sizeof(uhci_root_hub_t));
-        if (!rh) {
-                usb_log_error("Failed to allocate memory for driver instance.\n");
-                return ENOMEM;
+        }
         uintptr_t io_regs = 0;
         size_t io_size = 0;
         int ret = hc_get_my_registers(device, &io_regs, &io_size);
+        assert(ret == EOK);
+        if (ret != EOK) {
+                usb_log_error("Failed(%d) to get registers from parent hc.",
+                    ret);
+        }
+        usb_log_info("I/O regs at %#X (size %zu).\n", io_regs, io_size);
+        /* TODO: verify values from hc */
+        usb_log_info("I/O regs at 0x%X (size %zu).\n", io_regs, io_size);
+        uhci_root_hub_t *rh = malloc(sizeof(uhci_root_hub_t));
+        if (!rh) {
+                usb_log_error("Failed to allocate driver instance.\n");
+                return ENOMEM;
+        }
         ret = uhci_root_hub_init(rh, (void*)io_regs, io_size, device);
         if (ret != EOK) {
 …
 };
 /*----------------------------------------------------------------------------*/
 /** Initializes global driver structures (NONE).
+/** Initialize global driver structures (NONE).
+ *
  * @param[in] argc Nmber of arguments in argv vector (ignored).

uspace/drv/uhci-rhd/port.c

-              r45dd8bf
+              r4f66cc7b
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcirh
  * @{
  */
 /** @file
+ * @brief UHCI driver
+ */
+ * @brief UHCI root hub port routines
+ */
+#include <libarch/ddi.h> /* pio_read and pio_write */
 #include <errno.h>
 #include <str_error.h>
 …
 #include <usb/usb.h>    /* usb_address_t */
-#include <usb/usbdevice.h>
 #include <usb/hub.h>
-#include <usb/request.h>
 #include <usb/debug.h>
-#include <usb/recognise.h>
 #include "port.h"
-#include "port_status.h"
 static int uhci_port_new_device(uhci_port_t *port, usb_speed_t speed);
 …
 static int uhci_port_check(void *port);
 static int uhci_port_reset_enable(int portno, void *arg);
+/*----------------------------------------------------------------------------*/
+/** Initializes UHCI root hub port instance.
+static void uhci_port_print_status(
+    uhci_port_t *port, const port_status_t value);
+/** Register reading helper function.
+ *
+ * @param[in] port Structure to use.
+ * @return Error code. (Always EOK)
+ */
+static inline port_status_t uhci_port_read_status(uhci_port_t *port)
+{
+        assert(port);
+        return pio_read_16(port->address);
+}
+/*----------------------------------------------------------------------------*/
+/** Register writing helper function.
+ *
+ * @param[in] port Structure to use.
+ * @param[in] value New register value.
+ * @return Error code. (Always EOK)
+ */
+static inline void uhci_port_write_status(
+    uhci_port_t *port, port_status_t value)
+{
+        assert(port);
+        pio_write_16(port->address, value);
+}
+/*----------------------------------------------------------------------------*/
+/** Initialize UHCI root hub port instance.
+ *
  * @param[in] port Memory structure to use.
 …
  * @return Error code.
+ *
  * Starts the polling fibril.
+ * Creates and starts the polling fibril.
  */
 int uhci_port_init(uhci_port_t *port,
 …
+{
         assert(port);
+        asprintf(&port->id_string, "Port (%p - %d)", port, number);
+        if (port->id_string == NULL) {
+                return ENOMEM;
+        }
         port->address = address;
 …
         port->checker = fibril_create(uhci_port_check, port);
         if (port->checker == 0) {
                 usb_log_error("Port(%p - %d): failed to launch root hub fibril.",
                     port->address, port->number);
+                usb_log_error("%s: failed to create polling fibril.",
+                    port->id_string);
                 return ENOMEM;
+        }
         fibril_add_ready(port->checker);
         usb_log_debug("Port(%p - %d): Added fibril. %x\n",
             port->address, port->number, port->checker);
         return EOK;
+}
 /*----------------------------------------------------------------------------*/
 /** Finishes UHCI root hub port instance.
+        usb_log_debug("%s: Started polling fibril(%x).\n",
+            port->id_string, port->checker);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Cleanup UHCI root hub port instance.
+ *
  * @param[in] port Memory structure to use.
 …
 void uhci_port_fini(uhci_port_t *port)
+{
+        assert(port);
+        free(port->id_string);
         /* TODO: Kill fibril here */
         return;
 …
 /** Periodically checks port status and reports new devices.
+ *
  * @param[in] port Memory structure to use.
+ * @param[in] port Port structure to use.
  * @return Error code.
  */
 …
         assert(instance);
-        /* Iteration count, for debug purposes only */
-        unsigned count = 0;
         while (1) {
                 async_usleep(instance->wait_period_usec);
+                /* read register value */
+                port_status_t port_status = port_status_read(instance->address);
+                /* debug print mutex */
+                static fibril_mutex_t dbg_mtx =
+                    FIBRIL_MUTEX_INITIALIZER(dbg_mtx);
+                fibril_mutex_lock(&dbg_mtx);
+                usb_log_debug2("Port(%p - %d): Status: %#04x. === %u\n",
+                  instance->address, instance->number, port_status, count++);
+//              print_port_status(port_status);
+                fibril_mutex_unlock(&dbg_mtx);
+                /* Read register value */
+                port_status_t port_status = uhci_port_read_status(instance);
+                /* Print the value if it's interesting */
+                if (port_status & ~STATUS_ALWAYS_ONE)
+                        uhci_port_print_status(instance, port_status);
                 if ((port_status & STATUS_CONNECTED_CHANGED) == 0)
                         continue;
                 usb_log_debug("Port(%p - %d): Connected change detected: %x.\n",
                     instance->address, instance->number, port_status);
+                usb_log_debug("%s: Connected change detected: %x.\n",
+                    instance->id_string, port_status);
                 int rc =
                     usb_hc_connection_open(&instance->hc_connection);
                 if (rc != EOK) {
                         usb_log_error("Port(%p - %d): Failed to connect to HC.",
                             instance->address, instance->number);
+                        usb_log_error("%s: Failed to connect to HC.",
+                            instance->id_string);
                         continue;
+                }
 …
                 /* Remove any old device */
                 if (instance->attached_device) {
                         usb_log_debug2("Port(%p - %d): Removing device.\n",
                             instance->address, instance->number);
+                        usb_log_debug2("%s: Removing device.\n",
+                            instance->id_string);
                         uhci_port_remove_device(instance);
+                }
 …
                 } else {
                         /* Write one to WC bits, to ack changes */
                         port_status_write(instance->address, port_status);
                         usb_log_debug("Port(%p - %d): Change status ACK.\n",
                             instance->address, instance->number);
+                        uhci_port_write_status(instance, port_status);
+                        usb_log_debug("%s: status change ACK.\n",
+                            instance->id_string);
+                }
                 rc = usb_hc_connection_close(&instance->hc_connection);
                 if (rc != EOK) {
                         usb_log_error("Port(%p - %d): Failed to disconnect.",
                             instance->address, instance->number);
+                        usb_log_error("%s: Failed to disconnect.",
+                            instance->id_string);
+                }
+        }
 …
  * @param arg Pointer to uhci_port_t of port with the new device.
  * @return Error code.
+ *
+ * Resets and enables the ub port.
  */
 int uhci_port_reset_enable(int portno, void *arg)
 …
         uhci_port_t *port = (uhci_port_t *) arg;
+        usb_log_debug2("Port(%p - %d): new_device_enable_port.\n",
+            port->address, port->number);
+        usb_log_debug2("%s: new_device_enable_port.\n", port->id_string);
         /*
 …
         async_usleep(100000);
+        /* The hub maintains the reset signal to that port for 10 ms
+         * (See Section 11.5.1.5)
+        /*
+         * Resets from root ports should be nominally 50ms
          */
+        {
+                usb_log_debug("Port(%p - %d): Reset Signal start.\n",
+                    port->address, port->number);
+                port_status_t port_status =
+                        port_status_read(port->address);
+                usb_log_debug("%s: Reset Signal start.\n", port->id_string);
+                port_status_t port_status = uhci_port_read_status(port);
                 port_status |= STATUS_IN_RESET;
                 port_status_write(port->address, port_status);
                 async_usleep(10000);
                 port_status = port_status_read(port->address);
+                uhci_port_write_status(port, port_status);
+                async_usleep(50000);
+                port_status = uhci_port_read_status(port);
                 port_status &= ~STATUS_IN_RESET;
+                port_status_write(port->address, port_status);
+                usb_log_debug("Port(%p - %d): Reset Signal stop.\n",
+                    port->address, port->number);
+        }
+                uhci_port_write_status(port, port_status);
+                usb_log_debug("%s: Reset Signal stop.\n", port->id_string);
+        }
+        /* the reset recovery time 10ms */
+        async_usleep(10000);
         /* Enable the port. */
         uhci_port_set_enabled(port, true);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Initializes and reports connected device.
+ *
+ * @param[in] port Memory structure to use.
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Initialize and report connected device.
+ *
+ * @param[in] port Port structure to use.
  * @param[in] speed Detected speed.
  * @return Error code.
 …
         assert(usb_hc_connection_is_opened(&port->hc_connection));
+        usb_log_info("Port(%p-%d): Detected new device.\n",
+            port->address, port->number);
+        usb_log_info("%s: Detected new device.\n", port->id_string);
         usb_address_t dev_addr;
 …
         if (rc != EOK) {
                 usb_log_error("Port(%p-%d): Failed(%d) to add device: %s.\n",
                     port->address, port->number, rc, str_error(rc));
+                usb_log_error("%s: Failed(%d) to add device: %s.\n",
+                    port->id_string, rc, str_error(rc));
                 uhci_port_set_enabled(port, false);
                 return rc;
+        }
         usb_log_info("Port(%p-%d): New device has address %d (handle %zu).\n",
             port->address, port->number, dev_addr, port->attached_device);
         return EOK;
+}
 /*----------------------------------------------------------------------------*/
 /** Removes device.
+        usb_log_info("%s: New device has address %d (handle %zu).\n",
+            port->id_string, dev_addr, port->attached_device);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Remove device.
+ *
  * @param[in] port Memory structure to use.
  * @return Error code.
+ *
+ * Does not work DDF does not support device removal.
+ * Does not work, DDF does not support device removal.
+ * Does not even free used USB address (it would be dangerous if tis driver
+ * is still running).
  */
 int uhci_port_remove_device(uhci_port_t *port)
+{
+        usb_log_error("Port(%p-%d): Don't know how to remove device %#x.\n",
+            port->address, port->number, (unsigned int)port->attached_device);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Enables and disables port.
+ *
+ * @param[in] port Memory structure to use.
+        usb_log_error("%s: Don't know how to remove device %d.\n",
+            port->id_string, (unsigned int)port->attached_device);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Enable or disable root hub port.
+ *
+ * @param[in] port Port structure to use.
+ * @param[in] enabled Port status to set.
  * @return Error code. (Always EOK)
  */
 …
         /* Read register value */
         port_status_t port_status = port_status_read(port->address);
+        port_status_t port_status = uhci_port_read_status(port);
         /* Set enabled bit */
 …
         /* Write new value. */
+        port_status_write(port->address, port_status);
+        usb_log_info("Port(%p-%d): %sabled port.\n",
+                port->address, port->number, enabled ? "En" : "Dis");
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+        uhci_port_write_status(port, port_status);
+        usb_log_info("%s: %sabled port.\n",
+                port->id_string, enabled ? "En" : "Dis");
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Print the port status value in a human friendly way
+ *
+ * @param[in] port Port structure to use.
+ * @param[in] value Port register value to print.
+ * @return Error code. (Always EOK)
+ */
+void uhci_port_print_status(uhci_port_t *port, const port_status_t value)
+{
+        assert(port);
+        usb_log_debug2("%s Port status(%#x):%s%s%s%s%s%s%s%s%s%s%s.\n",
+            port->id_string, value,
+            (value & STATUS_SUSPEND) ? " SUSPENDED," : "",
+            (value & STATUS_RESUME) ? " IN RESUME," : "",
+            (value & STATUS_IN_RESET) ? " IN RESET," : "",
+            (value & STATUS_LINE_D_MINUS) ? " VD-," : "",
+            (value & STATUS_LINE_D_PLUS) ? " VD+," : "",
+            (value & STATUS_LOW_SPEED) ? " LOWSPEED," : "",
+            (value & STATUS_ENABLED_CHANGED) ? " ENABLED-CHANGE," : "",
+            (value & STATUS_ENABLED) ? " ENABLED," : "",
+            (value & STATUS_CONNECTED_CHANGED) ? " CONNECTED-CHANGE," : "",
+            (value & STATUS_CONNECTED) ? " CONNECTED," : "",
+            (value & STATUS_ALWAYS_ONE) ? " ALWAYS ONE" : " ERROR: NO ALWAYS ONE"
+        );
+}
 /**
  * @}

uspace/drv/uhci-rhd/port.h

-              r45dd8bf
+              r4f66cc7b
 /*
  * 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 drvusbuhcirh
  * @{
  */
 /** @file
  * @brief UHCI port driver
+ * @brief UHCI root hub port routines
  */
 #ifndef DRV_UHCI_PORT_H
 #define DRV_UHCI_PORT_H
+#include <assert.h>
+#include <stdint.h>
+#include <fibril.h>
 #include <ddf/driver.h>
+#include <stdint.h>
+#include <usb/usbdevice.h>
+#include <usb/usbdevice.h> /* usb_hc_connection_t */
+#include "port_status.h"
+typedef uint16_t port_status_t;
+#define STATUS_CONNECTED         (1 << 0)
+#define STATUS_CONNECTED_CHANGED (1 << 1)
+#define STATUS_ENABLED           (1 << 2)
+#define STATUS_ENABLED_CHANGED   (1 << 3)
+#define STATUS_LINE_D_PLUS       (1 << 4)
+#define STATUS_LINE_D_MINUS      (1 << 5)
+#define STATUS_RESUME            (1 << 6)
+#define STATUS_ALWAYS_ONE        (1 << 7)
+#define STATUS_LOW_SPEED (1 <<  8)
+#define STATUS_IN_RESET  (1 <<  9)
+#define STATUS_SUSPEND   (1 << 12)
 typedef struct uhci_port
+{
+        char *id_string;
         port_status_t *address;
         unsigned number;
 …
 void uhci_port_fini(uhci_port_t *port);
 #endif
 /**

uspace/drv/uhci-rhd/root_hub.c

-              r45dd8bf
+              r4f66cc7b
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 /** @addtogroup usb
+/** @addtogroup drvusbuhcirh
  * @{
  */
 /** @file
  * @brief UHCI driver
+ * @brief UHCI root hub driver
  */
 #include <errno.h>
-#include <stdint.h>
 #include <ddi.h>
-#include <devman.h>
 #include <usb/debug.h>
 #include "root_hub.h"
 /** Initializes UHCI root hub instance.
+/** Initialize UHCI root hub instance.
+ *
  * @param[in] instance Driver memory structure to use.
  * @param[in] addr Address of I/O registers.
  * @param[in] size Size of available I/O space.
  * @param[in] rh Pointer to ddf instance fo the root hub driver.
+ * @param[in] rh Pointer to ddf instance of the root hub driver.
  * @return Error code.
  */
 …
         if (ret < 0) {
                 usb_log_error(
+                    "Failed to gain access to port registers at %p\n", regs);
+                    "Failed(%d) to gain access to port registers at %p\n",
+                    ret, regs);
                 return ret;
+        }
         /* add fibrils for periodic port checks */
+        /* Initialize root hub ports */
         unsigned i = 0;
         for (; i < UHCI_ROOT_HUB_PORT_COUNT; ++i) {
 …
+}
 /*----------------------------------------------------------------------------*/
 /** Finishes UHCI root hub instance.
+/** Cleanup UHCI root hub instance.
+ *
  * @param[in] instance Driver memory structure to use.
+ * @param[in] instance Root hub structure to use.
  * @return Error code.
  */

uspace/drv/uhci-rhd/root_hub.h

-              r45dd8bf
+              r4f66cc7b
 /*
  * 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 drvusbuhcirh
  * @{
  */
 …
 #define DRV_UHCI_ROOT_HUB_H
-#include <fibril.h>
 #include <ddf/driver.h>

uspace/drv/usbhid/hiddev.c

-              r45dd8bf
+              r4f66cc7b
                 return rc;
+        }
+        rc = usb_endpoint_pipe_probe_default_control(&hid_dev->ctrl_pipe);
+        if (rc != EOK) {
+                usb_log_error("Probing default control pipe failed: %s.\n",
+                    str_error(rc));
+                return rc;
+        }
         /*

uspace/drv/usbhid/kbddev.c

r45dd8bf	r4f66cc7b
459	459	usbhid_kbd_push_ev(kbd_dev, KEY_PRESS, key);
460	460	usbhid_kbd_repeat_start(kbd_dev, key);
461		} else {~~size_t~~
	461	} else {
462	462	// found, nothing happens
463	463	}

uspace/drv/usbhub/usbhub.c

-              r45dd8bf
+              r4f66cc7b
 int usb_hub_control_loop(void * hub_info_param){
         usb_hub_info_t * hub_info = (usb_hub_info_t*)hub_info_param;
+        while(true){
+                usb_hub_check_hub_changes(hub_info);
+        int errorCode = EOK;
+        while(errorCode == EOK){
+                errorCode = usb_hub_check_hub_changes(hub_info);
                 async_usleep(1000 * 1000 );/// \TODO proper number once
+        }
+        dprintf(USB_LOG_LEVEL_ERROR,
+                                "something in ctrl loop went wrong, errno %d",errorCode);
         return 0;
+}
 …
                 dprintf(USB_LOG_LEVEL_ERROR,
                                 "could not initialize connection to device endpoint, errno %d",opResult);
+        }
+        return opResult;
+                return opResult;
+        }
+        opResult = usb_endpoint_pipe_probe_default_control(&hub->endpoints.control);
+        if (opResult != EOK) {
+                dprintf(USB_LOG_LEVEL_ERROR, "failed probing endpoint 0, %d", opResult);
+                return opResult;
+        }
+        return EOK;
+}
 …
  * @param target
  */
+static void usb_hub_init_add_device(usb_hub_info_t * hub, uint16_t port) {
+static void usb_hub_init_add_device(usb_hub_info_t * hub, uint16_t port,
+                bool isLowSpeed) {
         usb_device_request_setup_packet_t request;
         int opResult;
 …
         assert(hub->endpoints.control.hc_phone);
         //get default address
         //opResult = usb_drv_reserve_default_address(hc);
         opResult = usb_hc_reserve_default_address(&hub->connection, USB_SPEED_LOW);
+        usb_speed_t speed = isLowSpeed?USB_SPEED_LOW:USB_SPEED_FULL;
+        opResult = usb_hc_reserve_default_address(&hub->connection, speed);
         if (opResult != EOK) {
 …
                         &new_device_pipe,
                         &new_device_connection);
+        usb_endpoint_pipe_probe_default_control(&new_device_pipe);
         /// \TODO get highspeed info
         usb_speed_t speed = isLowSpeed?USB_SPEED_LOW:USB_SPEED_FULL;
 …
         usb_address_t new_device_address = usb_hc_request_address(
                         &hub->connection,
                         speed/// \TODO fullspeed??
+                        speed
                         );
         if (new_device_address < 0) {
 …
 static void usb_hub_removed_device(
     usb_hub_info_t * hub,uint16_t port) {
+        //usb_device_request_setup_packet_t request;
+        int opResult;
         /** \TODO remove device from device manager - not yet implemented in
          * devide manager
 …
         //close address
         if(hub->attached_devs[port].address!=0){
                 //opResult = usb_drv_release_address(hc,hub->attached_devs[port].address);
+                /*uncomment this code to use it when DDF allows device removal
                 opResult = usb_hc_unregister_device(
                                 &hub->connection, hub->attached_devs[port].address);
 …
                 hub->attached_devs[port].address = 0;
                 hub->attached_devs[port].handle = 0;
+                 */
         }else{
                 dprintf(USB_LOG_LEVEL_WARNING, "this is strange, disconnected device had no address");
 …
                 if (usb_port_dev_connected(&status)) {
                         dprintf(USB_LOG_LEVEL_INFO, "some connection changed");
                         usb_hub_init_add_device(hub, port);
+                        usb_hub_init_add_device(hub, port, usb_port_low_speed(&status));
                 } else {
                         usb_hub_removed_device(hub, port);
 …
 /**
  * Check changes on particular hub
+ * @param hub_info_param
+ */
+void usb_hub_check_hub_changes(usb_hub_info_t * hub_info){
+ * @param hub_info_param pointer to usb_hub_info_t structure
+ * @return error code if there is problem when initializing communication with
+ * hub, EOK otherwise
+ */
+int usb_hub_check_hub_changes(usb_hub_info_t * hub_info){
         int opResult;
         opResult = usb_endpoint_pipe_start_session(&hub_info->endpoints.status_change);
 …
                 dprintf(USB_LOG_LEVEL_ERROR,
                                 "could not initialize communication for hub; %d", opResult);
                 return;
+                return opResult;
+        }
 …
                 dprintf(USB_LOG_LEVEL_WARNING, "something went wrong while getting status of hub");
                 usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
                 return;
+                return opResult;
+        }
         unsigned int port;
 …
                                 opResult);
                 usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
                 return;
+                return opResult;
+        }
         opResult = usb_hc_connection_open(&hub_info->connection);
 …
                 usb_endpoint_pipe_end_session(&hub_info->endpoints.control);
                 usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
                 return;
+                return opResult;
+        }
 …
         usb_endpoint_pipe_end_session(&hub_info->endpoints.status_change);
         free(change_bitmap);
+        return EOK;
+}

uspace/drv/usbhub/usbhub.h

-              r45dd8bf
+              r4f66cc7b
 /**
  * check changes on specified hub
+ * Check changes on specified hub
  * @param hub_info_param pointer to usb_hub_info_t structure
+ * @return error code if there is problem when initializing communication with
+ * hub, EOK otherwise
  */
 void usb_hub_check_hub_changes(usb_hub_info_t * hub_info_param);
+int usb_hub_check_hub_changes(usb_hub_info_t * hub_info_param);

uspace/drv/usbmid/usbmid.c

-              r45dd8bf
+              r4f66cc7b
                 return NULL;
+        }
+        rc = usb_endpoint_pipe_probe_default_control(&mid->ctrl_pipe);
+        if (rc != EOK) {
+                usb_log_error("Probing default control pipe failed: %s.\n",
+                    str_error(rc));
+                free(mid);
+                return NULL;
+        }
         mid->dev = dev;

uspace/drv/usbmouse/init.c

-              r45dd8bf
+              r4f66cc7b
 /** Mouse polling endpoint description for boot protocol subclass. */
 static usb_endpoint_description_t poll_endpoint_description = {
+usb_endpoint_description_t poll_endpoint_description = {
         .transfer_type = USB_TRANSFER_INTERRUPT,
         .direction = USB_DIRECTION_IN,
 …
         .flags = 0
 };
-/** Initialize poll pipe.
+ *
- * Expects that session is already started on control pipe zero.
+ *
- * @param mouse Mouse device.
- * @param my_interface Interface number.
- * @return Error code.
- */
-static int intialize_poll_pipe(usb_mouse_t *mouse, int my_interface)
+{
-        assert(usb_endpoint_pipe_is_session_started(&mouse->ctrl_pipe));
-        int rc;
-        void *config_descriptor;
-        size_t config_descriptor_size;
-        rc = usb_request_get_full_configuration_descriptor_alloc(
-            &mouse->ctrl_pipe, 0, &config_descriptor, &config_descriptor_size);
-        if (rc != EOK) {
-                return rc;
+        }
-        usb_endpoint_mapping_t endpoint_mapping[1] = {
+                {
-                        .pipe = &mouse->poll_pipe,
-                        .description = &poll_endpoint_description,
-                        .interface_no = my_interface
+                }
-        };
-        rc = usb_endpoint_pipe_initialize_from_configuration(endpoint_mapping,
-, config_descriptor, config_descriptor_size, &mouse->wire);
-        if (rc != EOK) {
-                return rc;
+        }
-        if (!endpoint_mapping[0].present) {
-                return ENOENT;
+        }
-        mouse->poll_interval_us = 1000 * endpoint_mapping[0].descriptor->poll_interval;
-        usb_log_debug("prepared polling endpoint %d (interval %zu).\n",
-            mouse->poll_pipe.endpoint_no, mouse->poll_interval_us);
-        return EOK;
+}
 static void default_connection_handler(ddf_fun_t *, ipc_callid_t, ipc_call_t *);
 …
  * @return Error code.
  */
 int usb_mouse_create(ddf_dev_t *dev)
+int usb_mouse_create(usb_device_t *dev)
+{
         usb_mouse_t *mouse = malloc(sizeof(usb_mouse_t));
 …
                 return ENOMEM;
+        }
         mouse->device = dev;
+        mouse->dev = dev;
         mouse->console_phone = -1;
         int rc;
-        /* Initialize the backing connection. */
-        rc = usb_device_connection_initialize_from_device(&mouse->wire, dev);
-        if (rc != EOK) {
-                goto leave;
+        }
-        /* Initialize the default control pipe. */
-        rc = usb_endpoint_pipe_initialize_default_control(&mouse->ctrl_pipe,
-            &mouse->wire);
-        if (rc != EOK) {
-                goto leave;
+        }
-        rc = usb_endpoint_pipe_start_session(&mouse->ctrl_pipe);
-        if (rc != EOK) {
-                goto leave;
+        }
-        rc = intialize_poll_pipe(mouse, usb_device_get_assigned_interface(dev));
-        /* We can ignore error here. */
-        usb_endpoint_pipe_end_session(&mouse->ctrl_pipe);
-        if (rc != EOK) {
-                goto leave;
+        }
         /* Create DDF function. */
         mouse->mouse_fun = ddf_fun_create(dev, fun_exposed, "mouse");
+        mouse->mouse_fun = ddf_fun_create(dev->ddf_dev, fun_exposed, "mouse");
         if (mouse->mouse_fun == NULL) {
                 rc = ENOMEM;

uspace/drv/usbmouse/main.c

-              r45dd8bf
+              r4f66cc7b
  * @return Error code.
  */
 static int usbmouse_add_device(ddf_dev_t *dev)
+static int usbmouse_add_device(usb_device_t *dev)
+{
         int rc = usb_mouse_create(dev);
 …
+        }
+        fid_t poll_fibril = fibril_create(usb_mouse_polling_fibril, dev);
+        if (poll_fibril == 0) {
+                usb_log_error("Failed to initialize polling fibril.\n");
+                /* FIXME: free allocated resources. */
+                return ENOMEM;
+        usb_log_debug("Polling pipe at endpoint %d.\n", dev->pipes[0].pipe->endpoint_no);
+        rc = usb_device_auto_poll(dev, 0,
+            usb_mouse_polling_callback, dev->pipes[0].pipe->max_packet_size,
+            usb_mouse_polling_ended_callback, dev->driver_data);
+        if (rc != EOK) {
+                usb_log_error("Failed to start polling fibril: %s.\n",
+                    str_error(rc));
+                return rc;
+        }
-        fibril_add_ready(poll_fibril);
         usb_log_info("controlling new mouse (handle %llu).\n",
             dev->handle);
+            dev->ddf_dev->handle);
         return EOK;
 …
 /** USB mouse driver ops. */
 static driver_ops_t mouse_driver_ops = {
+static usb_driver_ops_t mouse_driver_ops = {
         .add_device = usbmouse_add_device,
 };
+static usb_endpoint_description_t *endpoints[] = {
+        &poll_endpoint_description,
+        NULL
+};
 /** USB mouse driver. */
 static driver_t mouse_driver = {
+static usb_driver_t mouse_driver = {
         .name = NAME,
+        .driver_ops = &mouse_driver_ops
+        .ops = &mouse_driver_ops,
+        .endpoints = endpoints
 };
 …
         usb_log_enable(USB_LOG_LEVEL_DEBUG, NAME);
         return ddf_driver_main(&mouse_driver);
+        return usb_driver_main(&mouse_driver);
+}

uspace/drv/usbmouse/mouse.c

-              r45dd8bf
+              r4f66cc7b
 #include <ipc/mouse.h>
 /** Fibril function for polling the mouse device.
+/** Mouse polling callback.
+ *
  * This function shall not terminate unless the device breaks and fails
  * to send data (e.g. stalls on data request).
+ *
  * @param arg ddf_dev_t type representing the mouse device.
  * @return EOK Always.
+ * @param dev Device that is being polled.
+ * @param buffer Data buffer.
+ * @param buffer_size Buffer size in bytes.
+ * @param arg Custom argument - points to usb_mouse_t.
+ * @return Always true.
  */
+int usb_mouse_polling_fibril(void *arg)
+bool usb_mouse_polling_callback(usb_device_t *dev,
+    uint8_t *buffer, size_t buffer_size, void *arg)
+{
+        assert(arg != NULL);
+        ddf_dev_t *dev = (ddf_dev_t *) arg;
+        usb_mouse_t *mouse = (usb_mouse_t *) dev->driver_data;
+        usb_mouse_t *mouse = (usb_mouse_t *) arg;
+        assert(mouse);
+        usb_log_debug2("got buffer: %s.\n",
+            usb_debug_str_buffer(buffer, buffer_size, 0));
+        size_t buffer_size = mouse->poll_pipe.max_packet_size;
+        uint8_t butt = buffer[0];
+        char str_buttons[4] = {
+                butt & 1 ? '#' : '.',
+                butt & 2 ? '#' : '.',
+                butt & 4 ? '#' : '.',
+        };
+        if (buffer_size < 4) {
+                usb_log_error("Weird mouse, results will be skewed.\n");
+                buffer_size = 4;
+        int shift_x = ((int) buffer[1]) - 127;
+        int shift_y = ((int) buffer[2]) - 127;
+        int wheel = ((int) buffer[3]) - 127;
+        if (buffer[1] == 0) {
+                shift_x = 0;
+        }
+        if (buffer[2] == 0) {
+                shift_y = 0;
+        }
+        if (buffer[3] == 0) {
+                wheel = 0;
+        }
+        uint8_t *buffer = malloc(buffer_size);
+        if (buffer == NULL) {
+                usb_log_error("Out of memory, poll fibril aborted.\n");
+                return ENOMEM;
+        if (mouse->console_phone >= 0) {
+                if ((shift_x != 0) || (shift_y != 0)) {
+                        /* FIXME: guessed for QEMU */
+                        async_req_2_0(mouse->console_phone,
+                            MEVENT_MOVE,
+                            - shift_x / 10,  - shift_y / 10);
+                }
+                if (butt) {
+                        /* FIXME: proper button clicking. */
+                        async_req_2_0(mouse->console_phone,
+                            MEVENT_BUTTON, 1, 1);
+                        async_req_2_0(mouse->console_phone,
+                            MEVENT_BUTTON, 1, 0);
+                }
+        }
         while (true) {
                 async_usleep(mouse->poll_interval_us);
+        usb_log_debug("buttons=%s  dX=%+3d  dY=%+3d  wheel=%+3d\n",
+            str_buttons, shift_x, shift_y, wheel);
                 size_t actual_size;
                 int rc;
+        /* Guess. */
+        async_usleep(1000);
+                /*
+                 * Error checking note:
+                 * - failure when starting a session is considered
+                 *   temporary (e.g. out of phones, next try might succeed)
+                 * - failure of transfer considered fatal (probably the
+                 *   device was unplugged)
+                 * - session closing not checked (shall not fail anyway)
+                 */
+        return true;
+}
+                rc = usb_endpoint_pipe_start_session(&mouse->poll_pipe);
+                if (rc != EOK) {
+                        usb_log_warning("Failed to start session, will try again: %s.\n",
+                            str_error(rc));
+                        continue;
+                }
+/** Callback when polling is terminated.
+ *
+ * @param dev Device where the polling terminated.
+ * @param recurring_errors Whether the polling was terminated due to
+ *      recurring errors.
+ * @param arg Custom argument - points to usb_mouse_t.
+ */
+void usb_mouse_polling_ended_callback(usb_device_t *dev,
+    bool recurring_errors, void *arg)
+{
+        usb_mouse_t *mouse = (usb_mouse_t *) arg;
-                rc = usb_endpoint_pipe_read(&mouse->poll_pipe,
-                    buffer, buffer_size, &actual_size);
-                usb_endpoint_pipe_end_session(&mouse->poll_pipe);
-                if (rc != EOK) {
-                        usb_log_error("Failed reading mouse input: %s.\n",
-                            str_error(rc));
-                        break;
+                }
-                usb_log_debug2("got buffer: %s.\n",
-                    usb_debug_str_buffer(buffer, buffer_size, 0));
-                uint8_t butt = buffer[0];
-                char str_buttons[4] = {
-                        butt & 1 ? '#' : '.',
-                        butt & 2 ? '#' : '.',
-                        butt & 4 ? '#' : '.',
-                };
-                int shift_x = ((int) buffer[1]) - 127;
-                int shift_y = ((int) buffer[2]) - 127;
-                int wheel = ((int) buffer[3]) - 127;
-                if (buffer[1] == 0) {
-                        shift_x = 0;
+                }
-                if (buffer[2] == 0) {
-                        shift_y = 0;
+                }
-                if (buffer[3] == 0) {
-                        wheel = 0;
+                }
-                if (mouse->console_phone >= 0) {
-                        if ((shift_x != 0) || (shift_y != 0)) {
-                                /* FIXME: guessed for QEMU */
-                                async_req_2_0(mouse->console_phone,
-                                    MEVENT_MOVE,
-                                    - shift_x / 10,  - shift_y / 10);
+                        }
-                        if (butt) {
-                                /* FIXME: proper button clicking. */
-                                async_req_2_0(mouse->console_phone,
-                                    MEVENT_BUTTON, 1, 1);
-                                async_req_2_0(mouse->console_phone,
-                                    MEVENT_BUTTON, 1, 0);
+                        }
+                }
-                usb_log_debug("buttons=%s  dX=%+3d  dY=%+3d  wheel=%+3d\n",
-                   str_buttons, shift_x, shift_y, wheel);
+        }
-        /*
-         * Device was probably unplugged.
-         * Hang-up the phone to the console.
-         * FIXME: release allocated memory.
-         */
         async_hangup(mouse->console_phone);
         mouse->console_phone = -1;
-        usb_log_error("Mouse polling fibril terminated.\n");
-        return EOK;
+}
 /**

uspace/drv/usbmouse/mouse.h

-              r45dd8bf
+              r4f66cc7b
 #define USBMOUSE_MOUSE_H_
 #include <ddf/driver.h>
+#include <usb/devdrv.h>
 #include <usb/pipes.h>
 #include <time.h>
 …
 typedef struct {
         /** Generic device container. */
         ddf_dev_t *device;
+        usb_device_t *dev;
         /** Function representing the device. */
         ddf_fun_t *mouse_fun;
-        /** Representation of connection to the device. */
-        usb_device_connection_t wire;
-        /** Default (zero) control pipe. */
-        usb_endpoint_pipe_t ctrl_pipe;
-        /** Polling (in) pipe. */
-        usb_endpoint_pipe_t poll_pipe;
         /** Polling interval in microseconds. */
         suseconds_t poll_interval_us;
 …
 } usb_mouse_t;
+int usb_mouse_create(ddf_dev_t *);
+#define POLL_PIPE(dev) ((dev)->pipes[0].pipe)
+int usb_mouse_polling_fibril(void *);
+extern usb_endpoint_description_t poll_endpoint_description;
+int usb_mouse_create(usb_device_t *);
+bool usb_mouse_polling_callback(usb_device_t *, uint8_t *, size_t, void *);
+void usb_mouse_polling_ended_callback(usb_device_t *, bool, void *);
 #endif

uspace/lib/block/libblock.c

-              r45dd8bf
+              r4f66cc7b
         l = hash_table_find(&cache->block_hash, &key);
         if (l) {
+found:
                 /*
                  * We found the block in the cache.
 …
                                         fibril_mutex_unlock(&b->lock);
                                         goto retry;
+                                }
+                                l = hash_table_find(&cache->block_hash, &key);
+                                if (l) {
+                                        /*
+                                         * Someone else must have already
+                                         * instantiated the block while we were
+                                         * not holding the cache lock.
+                                         * Leave the recycled block on the
+                                         * freelist and continue as if we
+                                         * found the block of interest during
+                                         * the first try.
+                                         */
+                                        fibril_mutex_unlock(&b->lock);
+                                        goto found;
+                                }

uspace/lib/drv/generic/remote_usbhc.c

-              r45dd8bf
+              r4f66cc7b
 static void remote_usbhc_bind_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 static void remote_usbhc_release_address(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_register_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
+static void remote_usbhc_unregister_endpoint(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 //static void remote_usbhc(ddf_fun_t *, void *, ipc_callid_t, ipc_call_t *);
 …
         remote_usbhc_control_write,
+        remote_usbhc_control_read
+        remote_usbhc_control_read,
+        remote_usbhc_register_endpoint,
+        remote_usbhc_unregister_endpoint
 };
 …
+void remote_usbhc_register_endpoint(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+        if (!usb_iface->register_endpoint) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+#define INIT_FROM_HIGH_DATA(type, var, arg_no) \
+        type var = (type) DEV_IPC_GET_ARG##arg_no(*call) / 256
+#define INIT_FROM_LOW_DATA(type, var, arg_no) \
+        type var = (type) DEV_IPC_GET_ARG##arg_no(*call) % 256
+        INIT_FROM_HIGH_DATA(usb_address_t, address, 1);
+        INIT_FROM_LOW_DATA(usb_endpoint_t, endpoint, 1);
+        INIT_FROM_HIGH_DATA(usb_transfer_type_t, transfer_type, 2);
+        INIT_FROM_LOW_DATA(usb_direction_t, direction, 2);
+#undef INIT_FROM_HIGH_DATA
+#undef INIT_FROM_LOW_DATA
+        size_t max_packet_size = (size_t) DEV_IPC_GET_ARG3(*call);
+        unsigned int interval  = (unsigned int) DEV_IPC_GET_ARG4(*call);
+        int rc = usb_iface->register_endpoint(fun, address, endpoint,
+            transfer_type, direction, max_packet_size, interval);
+        async_answer_0(callid, rc);
+}
+void remote_usbhc_unregister_endpoint(ddf_fun_t *fun, void *iface,
+    ipc_callid_t callid, ipc_call_t *call)
+{
+        usbhc_iface_t *usb_iface = (usbhc_iface_t *) iface;
+        if (!usb_iface->unregister_endpoint) {
+                async_answer_0(callid, ENOTSUP);
+                return;
+        }
+        usb_address_t address = (usb_address_t) DEV_IPC_GET_ARG1(*call);
+        usb_endpoint_t endpoint = (usb_endpoint_t) DEV_IPC_GET_ARG2(*call);
+        usb_direction_t direction = (usb_direction_t) DEV_IPC_GET_ARG3(*call);
+        int rc = usb_iface->unregister_endpoint(fun,
+            address, endpoint, direction);
+        async_answer_0(callid, rc);
+}
 /**

uspace/lib/drv/include/usbhc_iface.h

-              r45dd8bf
+              r4f66cc7b
         IPC_M_USBHC_CONTROL_READ,
+        /* IPC_M_USB_ */
+        /** Register endpoint attributes at host controller.
+         * This is used to reserve portion of USB bandwidth.
+         * Parameters:
+         * - USB address + endpoint number (ADDR * 256 + EP)
+         * - transfer type + direction (TYPE * 256 + DIR)
+         * - maximum packet size
+         * - interval (in milliseconds)
+         * Answer:
+         * - EOK - reservation successful
+         * - ELIMIT - not enough bandwidth to satisfy the request
+         */
+        IPC_M_USBHC_REGISTER_ENDPOINT,
+        /** Revert endpoint registration.
+         * Parameters:
+         * - USB address
+         * - endpoint number
+         * - data direction
+         * Answer:
+         * - EOK - endpoint unregistered
+         * - ENOENT - unknown endpoint
+         */
+        IPC_M_USBHC_UNREGISTER_ENDPOINT
 } usbhc_iface_funcs_t;
 …
         int (*release_address)(ddf_fun_t *, usb_address_t);
+        int (*register_endpoint)(ddf_fun_t *, usb_address_t, usb_endpoint_t,
+            usb_transfer_type_t, usb_direction_t, size_t, unsigned int);
+        int (*unregister_endpoint)(ddf_fun_t *, usb_address_t, usb_endpoint_t,
+            usb_direction_t);
         usbhc_iface_transfer_out_t interrupt_out;
         usbhc_iface_transfer_in_t interrupt_in;

uspace/lib/usb/Makefile

r45dd8bf	r4f66cc7b
37	37	src/ddfiface.c \
38	38	src/debug.c \
	39	src/devdrv.c \
	40	src/devpoll.c \
39	41	src/dp.c \
40	42	src/dump.c \

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

-              r45dd8bf
+              r4f66cc7b
         const usb_endpoint_description_t *description;
         /** Interface number the endpoint must belong to (-1 for any). */
         const int interface_no;
+        int interface_no;
         /** Found descriptor fitting the description. */
         usb_standard_endpoint_descriptor_t *descriptor;
 …
 int usb_endpoint_pipe_initialize_default_control(usb_endpoint_pipe_t *,
     usb_device_connection_t *);
+int usb_endpoint_pipe_probe_default_control(usb_endpoint_pipe_t *);
 int usb_endpoint_pipe_initialize_from_configuration(usb_endpoint_mapping_t *,
     size_t, uint8_t *, size_t, usb_device_connection_t *);
+int usb_endpoint_pipe_register(usb_endpoint_pipe_t *, unsigned int,
+    usb_hc_connection_t *);
+int usb_endpoint_pipe_unregister(usb_endpoint_pipe_t *, usb_hc_connection_t *);
 int usb_endpoint_pipe_start_session(usb_endpoint_pipe_t *);

uspace/lib/usb/src/hub.c

-              r45dd8bf
+              r4f66cc7b
                 goto leave_release_default_address;
+        }
+        rc = usb_endpoint_pipe_probe_default_control(&ctrl_pipe);
+        if (rc != EOK) {
+                rc = ENOTCONN;
+                goto leave_release_default_address;
+        }
         rc = usb_endpoint_pipe_start_session(&ctrl_pipe);

uspace/lib/usb/src/pipesinit.c

-              r45dd8bf
+              r4f66cc7b
 #include <usb/pipes.h>
 #include <usb/dp.h>
+#include <usb/request.h>
+#include <usbhc_iface.h>
 #include <errno.h>
 #include <assert.h>
+#define CTRL_PIPE_MIN_PACKET_SIZE 8
+#define DEV_DESCR_MAX_PACKET_SIZE_OFFSET 7
 …
         int rc = usb_endpoint_pipe_initialize(pipe, connection,
+, USB_TRANSFER_CONTROL, 8, USB_DIRECTION_BOTH);
+, USB_TRANSFER_CONTROL, CTRL_PIPE_MIN_PACKET_SIZE,
+            USB_DIRECTION_BOTH);
         return rc;
+}
+/** Probe default control pipe for max packet size.
+ *
+ * The function tries to get the correct value of max packet size several
+ * time before giving up.
+ *
+ * The session on the pipe shall not be started.
+ *
+ * @param pipe Default control pipe.
+ * @return Error code.
+ */
+int usb_endpoint_pipe_probe_default_control(usb_endpoint_pipe_t *pipe)
+{
+        assert(pipe);
+        assert(DEV_DESCR_MAX_PACKET_SIZE_OFFSET < CTRL_PIPE_MIN_PACKET_SIZE);
+        if ((pipe->direction != USB_DIRECTION_BOTH) ||
+            (pipe->transfer_type != USB_TRANSFER_CONTROL) ||
+            (pipe->endpoint_no != 0)) {
+                return EINVAL;
+        }
+#define TRY_LOOP(attempt_var) \
+        for (attempt_var = 0; attempt_var < 3; attempt_var++)
+        size_t failed_attempts;
+        int rc;
+        TRY_LOOP(failed_attempts) {
+                rc = usb_endpoint_pipe_start_session(pipe);
+                if (rc == EOK) {
+                        break;
+                }
+        }
+        if (rc != EOK) {
+                return rc;
+        }
+        uint8_t dev_descr_start[CTRL_PIPE_MIN_PACKET_SIZE];
+        size_t transferred_size;
+        TRY_LOOP(failed_attempts) {
+                rc = usb_request_get_descriptor(pipe, USB_REQUEST_TYPE_STANDARD,
+                    USB_REQUEST_RECIPIENT_DEVICE, USB_DESCTYPE_DEVICE,
+, 0, dev_descr_start, CTRL_PIPE_MIN_PACKET_SIZE,
+                    &transferred_size);
+                if (rc == EOK) {
+                        if (transferred_size != CTRL_PIPE_MIN_PACKET_SIZE) {
+                                rc = ELIMIT;
+                                continue;
+                        }
+                        break;
+                }
+        }
+        usb_endpoint_pipe_end_session(pipe);
+        if (rc != EOK) {
+                return rc;
+        }
+        pipe->max_packet_size
+            = dev_descr_start[DEV_DESCR_MAX_PACKET_SIZE_OFFSET];
+        return EOK;
+}
+/** Register endpoint with the host controller.
+ *
+ * @param pipe Pipe to be registered.
+ * @param interval Polling interval.
+ * @param hc_connection Connection to the host controller (must be opened).
+ * @return Error code.
+ */
+int usb_endpoint_pipe_register(usb_endpoint_pipe_t *pipe,
+    unsigned int interval,
+    usb_hc_connection_t *hc_connection)
+{
+        assert(pipe);
+        assert(hc_connection);
+        if (!usb_hc_connection_is_opened(hc_connection)) {
+                return EBADF;
+        }
+#define _PACK(high, low) ((high) * 256 + (low))
+        return async_req_5_0(hc_connection->hc_phone,
+            DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_REGISTER_ENDPOINT,
+            _PACK(pipe->wire->address, pipe->endpoint_no),
+            _PACK(pipe->transfer_type, pipe->direction),
+            pipe->max_packet_size, interval);
+#undef _PACK
+}
+/** Revert endpoint registration with the host controller.
+ *
+ * @param pipe Pipe to be unregistered.
+ * @param hc_connection Connection to the host controller (must be opened).
+ * @return Error code.
+ */
+int usb_endpoint_pipe_unregister(usb_endpoint_pipe_t *pipe,
+    usb_hc_connection_t *hc_connection)
+{
+        assert(pipe);
+        assert(hc_connection);
+        if (!usb_hc_connection_is_opened(hc_connection)) {
+                return EBADF;
+        }
+        return async_req_4_0(hc_connection->hc_phone,
+            DEV_IFACE_ID(USBHC_DEV_IFACE), IPC_M_USBHC_UNREGISTER_ENDPOINT,
+            pipe->wire->address, pipe->endpoint_no, pipe->direction);
+}

uspace/lib/usb/src/recognise.c

-              r45dd8bf
+              r4f66cc7b
                 goto failure;
+        }
+        rc = usb_endpoint_pipe_probe_default_control(&ctrl_pipe);
+        if (rc != EOK) {
+                goto failure;
+        }
         /*
 …
          * naming etc., something more descriptive could be created.
          */
+        rc = asprintf(&child_name, "usbdev%02zu", this_device_name_index);
+        rc = asprintf(&child_name, "usb%02zu_a%d",
+            this_device_name_index, address);
         if (rc < 0) {
                 goto failure;

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

-              r45dd8bf
+              r4f66cc7b
 #define NAME  "apic"
+static bool apic_found = false;
 static int apic_enable_irq(sysarg_t irq)
+{
 …
                 callid = async_get_call(&call);
+                switch (IPC_GET_IMETHOD(call)) {
+                sysarg_t method = IPC_GET_IMETHOD(call);
+                if (method == IPC_M_PHONE_HUNGUP) {
+                        return;
+                }
+                if (!apic_found) {
+                        async_answer_0(callid, ENOTSUP);
+                        break;
+                }
+                switch (method) {
                 case IRC_ENABLE_INTERRUPT:
                         async_answer_0(callid, apic_enable_irq(IPC_GET_ARG1(call)));
 …
+ *
  */
 static bool apic_init(void)
+static void apic_init(void)
+{
         sysarg_t apic;
         if ((sysinfo_get_value("apic", &apic) != EOK) || (!apic)) {
                 printf(NAME ": No APIC found\n");
                 return false;
+        apic_found = sysinfo_get_value("apic", &apic) && apic;
+        if (!apic_found) {
+                printf(NAME ": Warning: no APIC found\n");
+        }
         async_set_client_connection(apic_connection);
         service_register(SERVICE_APIC);
-        return true;
+}
 …
         printf(NAME ": HelenOS APIC driver\n");
+        if (!apic_init())
+                return -1;
+        apic_init();
         printf(NAME ": Accepting connections\n");
         async_manager();

Context Navigation

Changeset 4f66cc7b in mainline

Legend:

Download in other formats: