Changeset 1d115c8 in mainline

Timestamp:

2011-03-07T20:22:57Z (13 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

5d5f971

Parents:

0969e45e (diff), ec4538d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge development/ changes

Files:

• .bzrignore (modified) (2 diffs)
• boot/arch/mips32/src/asm.S (modified) (3 diffs)
• uspace/app/bdsh/cmds/modules/mkfile/mkfile.c (modified) (1 diff)
• uspace/drv/ehci-hcd/main.c (modified) (2 diffs)
• uspace/drv/ehci-hcd/pci.c (modified) (8 diffs)
• uspace/drv/uhci-hcd/batch.c (modified) (21 diffs)
• uspace/drv/uhci-hcd/iface.c (modified) (11 diffs)
• uspace/drv/uhci-hcd/main.c (modified) (5 diffs)
• uspace/drv/uhci-hcd/pci.c (modified) (5 diffs)
• uspace/drv/uhci-hcd/root_hub.c (modified) (5 diffs)
• uspace/drv/uhci-hcd/transfer_list.c (modified) (7 diffs)
• uspace/drv/uhci-hcd/transfer_list.h (modified) (1 diff)
• uspace/drv/uhci-hcd/uhci.c (modified) (15 diffs)
• uspace/drv/uhci-hcd/uhci.h (modified) (1 diff)
• uspace/drv/uhci-hcd/uhci_struct/queue_head.h (modified) (2 diffs)
• uspace/drv/uhci-hcd/uhci_struct/transfer_descriptor.c (modified) (2 diffs)
• uspace/drv/uhci-hcd/utils/device_keeper.c (modified) (14 diffs)
• uspace/drv/uhci-rhd/main.c (modified) (8 diffs)
• uspace/drv/uhci-rhd/port.c (modified) (10 diffs)
• uspace/drv/uhci-rhd/port_status.c (modified) (1 diff)
• uspace/drv/uhci-rhd/root_hub.c (modified) (4 diffs)

.bzrignore

@@ -77 +77 @@
 ./uspace/dist/srv/*
 ./uspace/drv/root/root
-./uspace/drv/ehci-hcd/ehci-hcd
 ./uspace/drv/isa/isa
 ./uspace/drv/ns8250/ns8250
@@ -85 +84 @@
 ./uspace/drv/test1/test1
 ./uspace/drv/test2/test2
+./uspace/drv/ehci-hcd/ehci-hcd
 ./uspace/drv/uhci-hcd/uhci-hcd
 ./uspace/drv/uhci-rhd/uhci-rhd

boot/arch/mips32/src/asm.S

@@ -41 +41 @@
 
 start:
-        /* Setup CPU map (on msim this code
-           is executed in parallel on all CPUs,
-           but it not an issue) */
+        /*
+         * Setup the CP0 configuration
+         *  - Disable 64-bit kernel addressing mode
+         *  - DIsable 64-bit supervisor adressing mode
+         *  - Disable 64-bit user addressing mode
+         */
+        mfc0 $a0, $status
+        la $a1, 0xffffff1f
+        and $a0, $a1, $a0
+        mtc0 $a0, $status
+        
+        /*
+         * Setup CPU map (on msim this code
+         * is executed in parallel on all CPUs,
+         * but it not an issue).
+         */
         la $a0, PA2KA(CPUMAP_OFFSET)
         
@@ -94 +107 @@
         lw $k1, ($k0)
         
-        /* If we are not running on BSP
-           then end in an infinite loop  */
+        /*
+         * If we are not running on BSP
+         * then end in an infinite loop.
+         */
         beq $k1, $zero, bsp
         nop
@@ -127 +142 @@
 
 jump_to_kernel:
-        #
-        # TODO:
-        # Make sure that the I-cache, D-cache and memory are mutually coherent
-        # before passing control to the copied code.
-        #
+        /*
+         * TODO:
+         *
+         * Make sure that the I-cache, D-cache and memory are mutually
+         * coherent before passing control to the copied code.
+         */
         j $a0
         nop

uspace/app/bdsh/cmds/modules/mkfile/mkfile.c

@@ -125 +125 @@
 
         for (c = 0, optind = 0, opt_ind = 0; c != -1;) {
-                c = getopt_long(argc, argv, "pvhVfm:", long_options, &opt_ind);
+                c = getopt_long(argc, argv, "s:h", long_options, &opt_ind);
                 switch (c) {
                 case 'h':

uspace/drv/ehci-hcd/main.c

@@ -58 +58 @@
 };
 /*----------------------------------------------------------------------------*/
+/** Initializes a new ddf driver instance of EHCI hcd.
+ *
+ * @param[in] device DDF instance of the device to initialize.
+ * @return Error code.
+ */
 static int ehci_add_device(ddf_dev_t *device)
 {
@@ -88 +93 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Initializes global driver structures (NONE).
+ *
+ * @param[in] argc Nmber of arguments in argv vector (ignored).
+ * @param[in] argv Cmdline argument vector (ignored).
+ * @return Error code.
+ *
+ * Driver debug level is set here.
+ */
 int main(int argc, char *argv[])
 {

uspace/drv/ehci-hcd/pci.c

@@ -48 +48 @@
 
 #define PAGE_SIZE_MASK 0xfffff000
+
 #define HCC_PARAMS_OFFSET 0x8
 #define HCC_PARAMS_EECP_MASK 0xff
 #define HCC_PARAMS_EECP_OFFSET 8
+
+#define CMD_OFFSET 0x0
+#define CONFIGFLAG_OFFSET 0x40
 
 #define USBCMD_RUN 1
@@ -62 +66 @@
 #define WAIT_STEP 10
 
-
 /** Get address of registers and IRQ for given device.
  *
  * @param[in] dev Device asking for the addresses.
- * @param[out] io_reg_address Base address of the I/O range.
- * @param[out] io_reg_size Size of the I/O range.
+ * @param[out] mem_reg_address Base address of the memory range.
+ * @param[out] mem_reg_size Size of the memory range.
  * @param[out] irq_no IRQ assigned to the device.
  * @return Error code.
@@ -87 +90 @@
         rc = hw_res_get_resource_list(parent_phone, &hw_resources);
         if (rc != EOK) {
-                goto leave;
+                async_hangup(parent_phone);
+                return rc;
         }
 
@@ -100 +104 @@
         for (i = 0; i < hw_resources.count; i++) {
                 hw_resource_t *res = &hw_resources.resources[i];
-                switch (res->type) {
-                        case INTERRUPT:
-                                irq = res->res.interrupt.irq;
-                                irq_found = true;
-                                usb_log_debug2("Found interrupt: %d.\n", irq);
-                                break;
-                        case MEM_RANGE:
-                                if (res->res.mem_range.address != 0
-                                    && res->res.mem_range.size != 0 ) {
-                                        mem_address = res->res.mem_range.address;
-                                        mem_size = res->res.mem_range.size;
-                                        usb_log_debug2("Found mem: %llx %zu.\n",
-                                                        res->res.mem_range.address, res->res.mem_range.size);
-                                        mem_found = true;
+                switch (res->type)
+                {
+                case INTERRUPT:
+                        irq = res->res.interrupt.irq;
+                        irq_found = true;
+                        usb_log_debug2("Found interrupt: %d.\n", irq);
+                        break;
+
+                case MEM_RANGE:
+                        if (res->res.mem_range.address != 0
+                            && res->res.mem_range.size != 0 ) {
+                                mem_address = res->res.mem_range.address;
+                                mem_size = res->res.mem_range.size;
+                                usb_log_debug2("Found mem: %llx %zu.\n",
+                                    mem_address, mem_size);
+                                mem_found = true;
                                 }
-                                break;
-                        default:
-                                break;
+                default:
+                        break;
                 }
         }
 
-        if (!mem_found) {
+        if (mem_found && irq_found) {
+                *mem_reg_address = mem_address;
+                *mem_reg_size = mem_size;
+                *irq_no = irq;
+                rc = EOK;
+        } else {
                 rc = ENOENT;
-                goto leave;
-        }
-
-        if (!irq_found) {
-                rc = ENOENT;
-                goto leave;
-        }
-
-        *mem_reg_address = mem_address;
-        *mem_reg_size = mem_size;
-        *irq_no = irq;
-
-        rc = EOK;
-leave:
+        }
+
         async_hangup(parent_phone);
-
         return rc;
 }
 /*----------------------------------------------------------------------------*/
+/** Calls the PCI driver with a request to enable interrupts
+ *
+ * @param[in] device Device asking for interrupts
+ * @return Error code.
+ */
 int pci_enable_interrupts(ddf_dev_t *device)
 {
-        int parent_phone = devman_parent_device_connect(device->handle,
-            IPC_FLAG_BLOCKING);
+        int parent_phone =
+            devman_parent_device_connect(device->handle, IPC_FLAG_BLOCKING);
+        if (parent_phone < 0) {
+                return parent_phone;
+        }
         bool enabled = hw_res_enable_interrupt(parent_phone);
         async_hangup(parent_phone);
@@ -151 +156 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Implements BIOS handoff routine as decribed in EHCI spec
+ *
+ * @param[in] device Device asking for interrupts
+ * @return Error code.
+ */
 int pci_disable_legacy(ddf_dev_t *device)
 {
@@ -160 +170 @@
         }
 
-        /* read register space BAR */
+#define CHECK_RET_HANGUP_RETURN(ret, message...) \
+        if (ret != EOK) { \
+                usb_log_error(message); \
+                async_hangup(parent_phone); \
+                return ret; \
+        } else (void)0
+
+
+        /* read register space BASE BAR */
         sysarg_t address = 0x10;
         sysarg_t value;
 
-  int ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
+        int ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
             IPC_M_CONFIG_SPACE_READ_32, address, &value);
+        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to read PCI config space.\n",
+            ret);
         usb_log_info("Register space BAR at %p:%x.\n", address, value);
 
-        /* clear lower byte, it's not part of the address */
+        /* clear lower byte, it's not part of the BASE address */
         uintptr_t registers = (value & 0xffffff00);
-        usb_log_info("Mem register address:%p.\n", registers);
-
-        /* if nothing setup the hc, the we don't need to to turn it off */
+        usb_log_info("Memory registers BASE address:%p.\n", registers);
+
+        /* if nothing setup the hc, we don't need to turn it off */
         if (registers == 0)
                 return ENOTSUP;
 
-        /* EHCI registers need 20 bytes*/
+        /* map EHCI registers */
         void *regs = as_get_mappable_page(4096);
         ret = physmem_map((void*)(registers & PAGE_SIZE_MASK), regs, 1,
             AS_AREA_READ | AS_AREA_WRITE);
-        if (ret != EOK) {
-                usb_log_error("Failed(%d) to map registers %p:%p.\n",
-                    ret, regs, registers);
-        }
+        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to map registers %p:%p.\n",
+            ret, regs, registers);
+
         /* calculate value of BASE */
         registers = (registers & 0xf00) | (uintptr_t)regs;
 
-        uint32_t hcc_params = *(uint32_t*)(registers + HCC_PARAMS_OFFSET);
-
+        const uint32_t hcc_params =
+            *(uint32_t*)(registers + HCC_PARAMS_OFFSET);
         usb_log_debug("Value of hcc params register: %x.\n", hcc_params);
-        uint32_t eecp = (hcc_params >> HCC_PARAMS_EECP_OFFSET) & HCC_PARAMS_EECP_MASK;
+
+        /* Read value of EHCI Extended Capabilities Pointer
+         * (points to PCI config space) */
+        uint32_t eecp =
+            (hcc_params >> HCC_PARAMS_EECP_OFFSET) & HCC_PARAMS_EECP_MASK;
         usb_log_debug("Value of EECP: %x.\n", eecp);
 
+        /* Read the second EEC. i.e. Legacy Support and Control register */
+        /* TODO: Check capability type here */
         ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
             IPC_M_CONFIG_SPACE_READ_32, eecp + USBLEGCTLSTS_OFFSET, &value);
-        if (ret != EOK) {
-                usb_log_error("Failed(%d) to read USBLEGCTLSTS.\n", ret);
-                return ret;
-        }
-        usb_log_debug2("USBLEGCTLSTS: %x.\n", value);
-
+        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to read USBLEGCTLSTS.\n", ret);
+        usb_log_debug("USBLEGCTLSTS: %x.\n", value);
+
+        /* Read the first EEC. i.e. Legacy Support register */
+        /* TODO: Check capability type here */
         ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
             IPC_M_CONFIG_SPACE_READ_32, eecp + USBLEGSUP_OFFSET, &value);
-        if (ret != EOK) {
-                usb_log_error("Failed(%d) to read USBLEGSUP.\n", ret);
-                return ret;
-        }
+        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to read USBLEGSUP.\n", ret);
         usb_log_debug2("USBLEGSUP: %x.\n", value);
 
-        /* request control from firmware/BIOS, by writing 1 to highest byte */
+        /* Request control from firmware/BIOS, by writing 1 to highest byte.
+         * (OS Control semaphore)*/
         ret = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
            IPC_M_CONFIG_SPACE_WRITE_8, eecp + USBLEGSUP_OFFSET + 3, 1);
-        if (ret != EOK) {
-                usb_log_error("Failed(%d) request OS EHCI control.\n", ret);
-                return ret;
-        }
-
-        size_t wait = 0; /* might be anything */
-        /* wait for BIOS to release control */
+        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to request OS EHCI control.\n",
+            ret);
+
+        size_t wait = 0;
+        /* Wait for BIOS to release control. */
         while ((wait < DEFAULT_WAIT) && (value & USBLEGSUP_BIOS_CONTROL)) {
                 async_usleep(WAIT_STEP);
                 ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-                                IPC_M_CONFIG_SPACE_READ_32, eecp + USBLEGSUP_OFFSET, &value);
+                    IPC_M_CONFIG_SPACE_READ_32, eecp + USBLEGSUP_OFFSET, &value);
                 wait += WAIT_STEP;
         }
 
+
         if ((value & USBLEGSUP_BIOS_CONTROL) != 0) {
-                usb_log_warning(
-                    "BIOS failed to release control after %d usecs, force it.\n",
-                    wait);
+                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"
+                    "%d usecs, force it.\n", wait);
                 ret = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
-                          IPC_M_CONFIG_SPACE_WRITE_32, eecp + USBLEGSUP_OFFSET,
+                    IPC_M_CONFIG_SPACE_WRITE_32, eecp + USBLEGSUP_OFFSET,
                     USBLEGSUP_OS_CONTROL);
-                if (ret != EOK) {
-                        usb_log_error("Failed(%d) to force OS EHCI control.\n", ret);
-                        return ret;
-                }
-        } else {
-                usb_log_info("BIOS released control after %d usec.\n",
-                    wait);
-        }
-
-
-        /* zero SMI enables in legacy control register */
+                CHECK_RET_HANGUP_RETURN(ret,
+                    "Failed(%d) to force OS EHCI control.\n", ret);
+                /* TODO: This does not seem to work on my machine */
+        }
+
+        /* Zero SMI enables in legacy control register.
+         * It would prevent pre-OS code from interfering. */
         ret = async_req_3_0(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
            IPC_M_CONFIG_SPACE_WRITE_32, eecp + USBLEGCTLSTS_OFFSET, 0);
-        if (ret != EOK) {
-                usb_log_error("Failed(%d) zero USBLEGCTLSTS.\n", ret);
-                return ret;
-        }
+        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) zero USBLEGCTLSTS.\n", ret);
         usb_log_debug("Zeroed USBLEGCTLSTS register.\n");
 
+        /* Read again Legacy Support and Control register */
         ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
             IPC_M_CONFIG_SPACE_READ_32, eecp + USBLEGCTLSTS_OFFSET, &value);
-        if (ret != EOK) {
-                usb_log_error("Failed(%d) to read USBLEGCTLSTS.\n", ret);
-                return ret;
-        }
+        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to read USBLEGCTLSTS.\n", ret);
         usb_log_debug2("USBLEGCTLSTS: %x.\n", value);
 
+        /* Read again Legacy Support register */
         ret = async_req_2_1(parent_phone, DEV_IFACE_ID(PCI_DEV_IFACE),
             IPC_M_CONFIG_SPACE_READ_32, eecp + USBLEGSUP_OFFSET, &value);
-        if (ret != EOK) {
-                usb_log_error("Failed(%d) to read USBLEGSUP.\n", ret);
-                return ret;
-        }
+        CHECK_RET_HANGUP_RETURN(ret, "Failed(%d) to read USBLEGSUP.\n", ret);
         usb_log_debug2("USBLEGSUP: %x.\n", value);
 
@@ -272 +284 @@
  */
 
-        /* size of capability registers in memory space */
+        /* Get size of capability registers in memory space. */
         uint8_t operation_offset = *(uint8_t*)registers;
         usb_log_debug("USBCMD offset: %d.\n", operation_offset);
-        /* zero USBCMD register */
+
+        /* Zero USBCMD register. */
         volatile uint32_t *usbcmd =
-         (uint32_t*)((uint8_t*)registers + operation_offset);
+            (uint32_t*)((uint8_t*)registers + operation_offset + CMD_OFFSET);
+        volatile uint32_t *usbconfigured =
+            (uint32_t*)((uint8_t*)registers + operation_offset
+            + CONFIGFLAG_OFFSET);
         usb_log_debug("USBCMD value: %x.\n", *usbcmd);
         if (*usbcmd & USBCMD_RUN) {
                 *usbcmd = 0;
+                *usbconfigured = 0;
                 usb_log_info("EHCI turned off.\n");
         } else {
@@ -286 +303 @@
         }
 
-
         async_hangup(parent_phone);
-
-  return ret;
+        return ret;
+#undef CHECK_RET_HANGUP_RETURN
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/uhci-hcd/batch.c

@@ -57 +57 @@
 
 
+/** Allocates memory and initializes internal data structures.
+ *
+ * @param[in] fun DDF function to pass to callback.
+ * @param[in] target Device and endpoint target of the transaction.
+ * @param[in] transfer_type Interrupt, Control or Bulk.
+ * @param[in] max_packet_size maximum allowed size of data packets.
+ * @param[in] speed Speed of the transaction.
+ * @param[in] buffer Data source/destination.
+ * @param[in] size Size of the buffer.
+ * @param[in] setup_buffer Setup data source (if not NULL)
+ * @param[in] setup_size Size of setup_buffer (should be always 8)
+ * @param[in] func_in function to call on inbound transaction completion
+ * @param[in] func_out function to call on outbound transaction completion
+ * @param[in] arg additional parameter to func_in or func_out
+ * @param[in] manager Pointer to toggle management structure.
+ * @return False, if there is an active TD, true otherwise.
+ */
 batch_t * batch_get(ddf_fun_t *fun, usb_target_t target,
     usb_transfer_type_t transfer_type, size_t max_packet_size,
@@ -69 +86 @@
         assert(func_in != NULL || func_out != NULL);
 
+#define CHECK_NULL_DISPOSE_RETURN(ptr, message...) \
+        if (ptr == NULL) { \
+                usb_log_error(message); \
+                if (instance) { \
+                        batch_dispose(instance); \
+                } \
+                return NULL; \
+        } else (void)0
+
         batch_t *instance = malloc(sizeof(batch_t));
-        if (instance == NULL) {
-                usb_log_error("Failed to allocate batch instance.\n");
-                return NULL;
-        }
-
-        instance->qh = queue_head_get();
-        if (instance->qh == NULL) {
-                usb_log_error("Failed to allocate queue head.\n");
-                free(instance);
-                return NULL;
-        }
+        CHECK_NULL_DISPOSE_RETURN(instance,
+            "Failed to allocate batch instance.\n");
+        bzero(instance, sizeof(batch_t));
+
+        instance->qh = malloc32(sizeof(queue_head_t));
+        CHECK_NULL_DISPOSE_RETURN(instance->qh,
+            "Failed to allocate batch queue head.\n");
+        queue_head_init(instance->qh);
 
         instance->packets = (size + max_packet_size - 1) / max_packet_size;
@@ -88 +111 @@
 
         instance->tds = malloc32(sizeof(td_t) * instance->packets);
-        if (instance->tds == NULL) {
-                usb_log_error("Failed to allocate transfer descriptors.\n");
-                queue_head_dispose(instance->qh);
-                free(instance);
-                return NULL;
-        }
+        CHECK_NULL_DISPOSE_RETURN(
+            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;
-
-        instance->transport_buffer =
-           (size > 0) ? malloc32(transport_size) : NULL;
-
-        if ((size > 0) && (instance->transport_buffer == NULL)) {
-                usb_log_error("Failed to allocate device accessible buffer.\n");
-                queue_head_dispose(instance->qh);
-                free32(instance->tds);
-                free(instance);
-                return NULL;
-        }
-
-        instance->setup_buffer = setup_buffer ? malloc32(setup_size) : NULL;
-        if ((setup_size > 0) && (instance->setup_buffer == NULL)) {
-                usb_log_error("Failed to allocate device accessible setup buffer.\n");
-                queue_head_dispose(instance->qh);
-                free32(instance->tds);
-                free32(instance->transport_buffer);
-                free(instance);
-                return NULL;
-        }
-        if (instance->setup_buffer) {
+//      const size_t transport_size = max_packet_size * instance->packets;
+
+        if (size > 0) {
+                instance->transport_buffer = malloc32(size);
+                CHECK_NULL_DISPOSE_RETURN(instance->transport_buffer,
+                    "Failed to allocate device accessible buffer.\n");
+        }
+
+        if (setup_size > 0) {
+                instance->setup_buffer = malloc32(setup_size);
+                CHECK_NULL_DISPOSE_RETURN(instance->setup_buffer,
+                    "Failed to allocate device accessible setup buffer.\n");
                 memcpy(instance->setup_buffer, setup_buffer, setup_size);
         }
 
+
+        link_initialize(&instance->link);
+
         instance->max_packet_size = max_packet_size;
-
-        link_initialize(&instance->link);
-
         instance->target = target;
         instance->transfer_type = transfer_type;
-
-        if (func_out)
-                instance->callback_out = func_out;
-        if (func_in)
-                instance->callback_in = func_in;
-
         instance->buffer = buffer;
         instance->buffer_size = size;
@@ -142 +144 @@
         instance->manager = manager;
 
-        queue_head_element_td(instance->qh, addr_to_phys(instance->tds));
+        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));
+
         usb_log_debug("Batch(%p) %d:%d memory structures ready.\n",
             instance, target.address, target.endpoint);
@@ -148 +156 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Checks batch TDs for activity.
+ *
+ * @param[in] instance Batch structure to use.
+ * @return False, if there is an active TD, true otherwise.
+ */
 bool batch_is_complete(batch_t *instance)
 {
@@ -165 +178 @@
                             instance, i, instance->tds[i].status);
 
-                        device_keeper_set_toggle(instance->manager, instance->target,
-                            td_toggle(&instance->tds[i]));
+                        device_keeper_set_toggle(instance->manager,
+                            instance->target, td_toggle(&instance->tds[i]));
                         if (i > 0)
                                 goto substract_ret;
@@ -181 +194 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Prepares control write transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_control_write(batch_t *instance)
 {
         assert(instance);
         /* we are data out, we are supposed to provide data */
-        memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
+        memcpy(instance->transport_buffer, instance->buffer,
+            instance->buffer_size);
         batch_control(instance, USB_PID_OUT, USB_PID_IN);
         instance->next_step = batch_call_out_and_dispose;
@@ -192 +210 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Prepares control read transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_control_read(batch_t *instance)
 {
@@ -201 +223 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Prepares interrupt in transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_interrupt_in(batch_t *instance)
 {
@@ -210 +236 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Prepares interrupt out transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_interrupt_out(batch_t *instance)
 {
         assert(instance);
+        /* we are data out, we are supposed to provide data */
         memcpy(instance->transport_buffer, instance->buffer, instance->buffer_size);
         batch_data(instance, USB_PID_OUT);
@@ -220 +251 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Prepares bulk in transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_bulk_in(batch_t *instance)
 {
@@ -229 +264 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Prepares bulk out transaction.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_bulk_out(batch_t *instance)
 {
@@ -239 +278 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Prepares generic data transaction
+ *
+ * @param[in] instance Batch structure to use.
+ * @param[in] pid to use for data packets.
+ */
 void batch_data(batch_t *instance, usb_packet_id pid)
 {
         assert(instance);
         const bool low_speed = instance->speed == USB_SPEED_LOW;
-        int toggle = device_keeper_get_toggle(instance->manager, instance->target);
+        int toggle =
+            device_keeper_get_toggle(instance->manager, instance->target);
         assert(toggle == 0 || toggle == 1);
 
@@ -253 +298 @@
                     - remain_size;
 
-
                 const size_t packet_size =
                     (instance->max_packet_size > remain_size) ?
                     remain_size : instance->max_packet_size;
 
-                td_init(&instance->tds[packet],
-                    DEFAULT_ERROR_COUNT, packet_size, toggle, false, low_speed,
-                    instance->target, pid, data,
-                    &instance->tds[packet + 1]);
+                td_t *next_packet = (packet + 1 < instance->packets)
+                    ? &instance->tds[packet + 1] : NULL;
+
+                assert(packet < instance->packets);
+                assert(packet_size <= remain_size);
+
+                td_init(
+                    &instance->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, instance->target, pid, data,
+                    next_packet);
+
 
                 toggle = 1 - toggle;
+                remain_size -= packet_size;
                 ++packet;
-                assert(packet <= instance->packets);
-                assert(packet_size <= remain_size);
-                remain_size -= packet_size;
         }
         device_keeper_set_toggle(instance->manager, instance->target, toggle);
-
-        instance->tds[packet - 1].status |= TD_STATUS_COMPLETE_INTERRUPT_FLAG;
-        instance->tds[packet - 1].next = 0 | LINK_POINTER_TERMINATE_FLAG;
-}
-/*----------------------------------------------------------------------------*/
+}
+/*----------------------------------------------------------------------------*/
+/** Prepares 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.
+ */
 void batch_control(batch_t *instance,
    usb_packet_id data_stage, usb_packet_id status_stage)
@@ -301 +353 @@
                     remain_size : instance->max_packet_size;
 
-                td_init(&instance->tds[packet],
-                    DEFAULT_ERROR_COUNT, packet_size, toggle, false, low_speed,
-                    instance->target, data_stage, data,
-                    &instance->tds[packet + 1]);
+                td_init(
+                    &instance->tds[packet], DEFAULT_ERROR_COUNT, packet_size,
+                    toggle, false, low_speed, instance->target, data_stage,
+                    data, &instance->tds[packet + 1]);
 
                 ++packet;
@@ -323 +375 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Prepares data, gets error status and calls callback in.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_call_in(batch_t *instance)
 {
@@ -328 +384 @@
         assert(instance->callback_in);
 
-        memcpy(instance->buffer, instance->transport_buffer, instance->buffer_size);
+        /* we are data in, we need data */
+        memcpy(instance->buffer, instance->transport_buffer,
+            instance->buffer_size);
 
         int err = instance->error;
@@ -335 +393 @@
             instance->transfered_size);
 
-        instance->callback_in(instance->fun,
-            err, instance->transfered_size,
-            instance->arg);
-}
-/*----------------------------------------------------------------------------*/
+        instance->callback_in(
+            instance->fun, err, instance->transfered_size, instance->arg);
+}
+/*----------------------------------------------------------------------------*/
+/** Gets error status and calls callback out.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_call_out(batch_t *instance)
 {
@@ -352 +413 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Prepares data, gets error status, calls callback in and dispose.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_call_in_and_dispose(batch_t *instance)
 {
@@ -359 +424 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Gets error status, calls callback out and dispose.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_call_out_and_dispose(batch_t *instance)
 {
@@ -366 +435 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Correctly disposes all used data structures.
+ *
+ * @param[in] instance Batch structure to use.
+ */
 void batch_dispose(batch_t *instance)
 {
         assert(instance);
         usb_log_debug("Batch(%p) disposing.\n", instance);
+        /* free32 is NULL safe */
         free32(instance->tds);
         free32(instance->qh);

uspace/drv/uhci-hcd/iface.c

@@ -43 +43 @@
 #include "utils/device_keeper.h"
 
+/** Reserve default address interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] speed Speed to associate with the new default address.
+ * @return Error code.
+ */
 /*----------------------------------------------------------------------------*/
 static int reserve_default_address(ddf_fun_t *fun, usb_speed_t speed)
@@ -54 +60 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Release default address interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @return Error code.
+ */
 static int release_default_address(ddf_fun_t *fun)
 {
@@ -64 +75 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Request address interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] speed Speed to associate with the new default address.
+ * @param[out] address Place to write a new address.
+ * @return Error code.
+ */
 static int request_address(ddf_fun_t *fun, usb_speed_t speed,
     usb_address_t *address)
@@ -80 +98 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Bind address interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] address Address of the device
+ * @param[in] handle Devman handle of the device driver.
+ * @return Error code.
+ */
 static int bind_address(
   ddf_fun_t *fun, usb_address_t address, devman_handle_t handle)
@@ -91 +116 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Release address interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] address USB address to be released.
+ * @return Error code.
+ */
 static int release_address(ddf_fun_t *fun, usb_address_t address)
 {
@@ -101 +132 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Interrupt out transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts
+ * @param[in] data Source of data.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
 static int interrupt_out(ddf_fun_t *fun, usb_target_t target,
     size_t max_packet_size, void *data, size_t size,
@@ -122 +164 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Interrupt in transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts
+ * @param[out] data Data destination.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
 static int interrupt_in(ddf_fun_t *fun, usb_target_t target,
     size_t max_packet_size, void *data, size_t size,
@@ -142 +195 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Bulk out transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts
+ * @param[in] data Source of data.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
 static int bulk_out(ddf_fun_t *fun, usb_target_t target,
     size_t max_packet_size, void *data, size_t size,
@@ -163 +227 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Bulk in transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts
+ * @param[out] data Data destination.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
 static int bulk_in(ddf_fun_t *fun, usb_target_t target,
     size_t max_packet_size, void *data, size_t size,
@@ -183 +258 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Control write transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts.
+ * @param[in] setup_data Data to send with SETUP packet.
+ * @param[in] setup_size Size of data to send with SETUP packet (should be 8B).
+ * @param[in] data Source of data.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion.
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
 static int control_write(ddf_fun_t *fun, usb_target_t target,
     size_t max_packet_size,
@@ -208 +296 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Control read transaction interface function
+ *
+ * @param[in] fun DDF function that was called.
+ * @param[in] target USB device to write to.
+ * @param[in] max_packet_size maximum size of data packet the device accepts.
+ * @param[in] setup_data Data to send with SETUP packet.
+ * @param[in] setup_size Size of data to send with SETUP packet (should be 8B).
+ * @param[out] data Source of data.
+ * @param[in] size Size of data source.
+ * @param[in] callback Function to call on transaction completion.
+ * @param[in] arg Additional for callback function.
+ * @return Error code.
+ */
 static int control_read(ddf_fun_t *fun, usb_target_t target,
     size_t max_packet_size,

uspace/drv/uhci-hcd/main.c

@@ -60 +60 @@
 };
 /*----------------------------------------------------------------------------*/
+/** 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)
 {
@@ -69 +75 @@
 }
 /*----------------------------------------------------------------------------*/
-static int uhci_add_device(ddf_dev_t *device)
+/** Initializes a new ddf driver instance of UHCI hcd.
+ *
+ * @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)
 {
         assert(device);
@@ -96 +110 @@
         ret = pci_disable_legacy(device);
         CHECK_RET_FREE_HC_RETURN(ret,
-            "Failed(%d) disable legacy USB: %s.\n", ret, str_error(ret));
+            "Failed(%d) to disable legacy USB: %s.\n", ret, str_error(ret));
 
 #if 0
@@ -113 +127 @@
 
         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);
+        CHECK_RET_FREE_HC_RETURN(ret, "Failed(%d) to init uhci-hcd.\n", ret);
 #undef CHECK_RET_FREE_HC_RETURN
 
@@ -155 +168 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Initializes global driver structures (NONE).
+ *
+ * @param[in] argc Nmber of arguments in argv vector (ignored).
+ * @param[in] argv Cmdline argument vector (ignored).
+ * @return Error code.
+ *
+ * Driver debug level is set here.
+ */
 int main(int argc, char *argv[])
 {

uspace/drv/uhci-hcd/pci.c

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

uspace/drv/uhci-hcd/root_hub.c

@@ -45 +45 @@
 
 /*----------------------------------------------------------------------------*/
-static int usb_iface_get_hc_handle_rh_impl(ddf_fun_t *root_hub_fun,
-    devman_handle_t *handle)
+/** Gets handle of the respective hc (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_rh_impl(
+    ddf_fun_t *root_hub_fun, devman_handle_t *handle)
 {
+        /* TODO: Can't this use parent pointer? */
         ddf_fun_t *hc_fun = root_hub_fun->driver_data;
         assert(hc_fun != NULL);
@@ -56 +63 @@
 }
 /*----------------------------------------------------------------------------*/
-static int usb_iface_get_address_rh_impl(ddf_fun_t *fun, devman_handle_t handle,
-    usb_address_t *address)
+/** Gets USB address of the calling device.
+ *
+ * @param[in] fun Root hub function.
+ * @param[in] handle Handle of the device seeking address.
+ * @param[out] address Place to store found address.
+ * @return Error code.
+ */
+static int usb_iface_get_address_rh_impl(
+    ddf_fun_t *fun, devman_handle_t handle, usb_address_t *address)
 {
+        /* TODO: What does this do? Is it neccessary? Can't it use implemented
+         * hc function?*/
         assert(fun);
         ddf_fun_t *hc_fun = fun->driver_data;
@@ -65 +81 @@
         assert(hc);
 
-        usb_address_t addr = device_keeper_find(&hc->device_manager,
-            handle);
+        usb_address_t addr = device_keeper_find(&hc->device_manager, handle);
         if (addr < 0) {
                 return addr;
@@ -83 +98 @@
 };
 /*----------------------------------------------------------------------------*/
+/** Gets root hub hw resources.
+ *
+ * @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 *dev)
 {
@@ -91 +111 @@
         assert(hc);
 
-        //TODO: fix memory leak
+        /* TODO: fix memory leak */
         hw_resource_list_t *resource_list = malloc(sizeof(hw_resource_list_t));
         assert(resource_list);

uspace/drv/uhci-hcd/transfer_list.c

@@ -38 +38 @@
 #include "transfer_list.h"
 
+static void transfer_list_remove_batch(
+    transfer_list_t *instance, batch_t *batch);
+/*----------------------------------------------------------------------------*/
+/** Initializes 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.
+ */
 int transfer_list_init(transfer_list_t *instance, const char *name)
 {
@@ -43 +54 @@
         instance->next = NULL;
         instance->name = name;
-        instance->queue_head = queue_head_get();
+        instance->queue_head = malloc32(sizeof(queue_head_t));
         if (!instance->queue_head) {
                 usb_log_error("Failed to allocate queue head.\n");
                 return ENOMEM;
         }
-        instance->queue_head_pa = (uintptr_t)addr_to_phys(instance->queue_head);
+        instance->queue_head_pa = addr_to_phys(instance->queue_head);
 
         queue_head_init(instance->queue_head);
@@ -56 +67 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Set the next list in chain.
+ *
+ * @param[in] instance List to lead.
+ * @param[in] next List to append.
+ * @return Error code
+ */
 void transfer_list_set_next(transfer_list_t *instance, transfer_list_t *next)
 {
@@ -66 +83 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Submits a new transfer batch to list and queue.
+ *
+ * @param[in] instance List to use.
+ * @param[in] batch Transfer batch to submit.
+ * @return Error code
+ */
 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);
+        usb_log_debug2(
+            "Adding batch(%p) to queue %s.\n", batch, instance->name);
 
         uint32_t pa = (uintptr_t)addr_to_phys(batch->qh);
@@ -97 +121 @@
         queue_head_append_qh(last->qh, pa);
         list_append(&batch->link, &instance->batch_list);
+
         usb_log_debug("Batch(%p) added to queue %s last, first is %p.\n",
-                batch, instance->name, first );
+                batch, instance->name, first);
         fibril_mutex_unlock(&instance->guard);
 }
 /*----------------------------------------------------------------------------*/
-static void transfer_list_remove_batch(
-    transfer_list_t *instance, batch_t *batch)
+/** Removes a transfer batch from list and queue.
+ *
+ * @param[in] instance List to use.
+ * @param[in] batch Transfer batch to remove.
+ * @return Error code
+ */
+void transfer_list_remove_batch(transfer_list_t *instance, batch_t *batch)
 {
         assert(instance);
@@ -109 +139 @@
         assert(instance->queue_head);
         assert(batch->qh);
-        usb_log_debug2("Removing batch(%p) from queue %s.\n", batch, instance->name);
+        usb_log_debug2(
+            "Removing batch(%p) from queue %s.\n", batch, instance->name);
 
-        /* I'm the first one here */
         if (batch->link.prev == &instance->batch_list) {
-                usb_log_debug("Batch(%p) removed (FIRST) from queue %s, next element %x.\n",
-                        batch, instance->name, batch->qh->next_queue);
+                /* 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;
         } else {
-                usb_log_debug("Batch(%p) removed (NOT FIRST) from queue, next element %x.\n",
-                        batch, instance->name, batch->qh->next_queue);
-                batch_t *prev = list_get_instance(batch->link.prev, batch_t, link);
+                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;
         }
@@ -125 +159 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Checks list for finished transfers.
+ *
+ * @param[in] instance List to use.
+ * @return Error code
+ */
 void transfer_list_remove_finished(transfer_list_t *instance)
 {

uspace/drv/uhci-hcd/transfer_list.h

@@ -58 +58 @@
 {
         assert(instance);
-        queue_head_dispose(instance->queue_head);
+        free32(instance->queue_head);
 }
 void transfer_list_remove_finished(transfer_list_t *instance);

uspace/drv/uhci-hcd/uhci.c

@@ -61 +61 @@
 };
 
-static int usb_iface_get_address(ddf_fun_t *fun, devman_handle_t handle,
-    usb_address_t *address)
+/** 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.
+ */
+static int usb_iface_get_address(
+    ddf_fun_t *fun, devman_handle_t handle, usb_address_t *address)
 {
         assert(fun);
@@ -99 +106 @@
 
 static bool allowed_usb_packet(
-        bool low_speed, usb_transfer_type_t, size_t size);
-
-
+    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)
 {
@@ -156 +171 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Initializes UHCI hcd hw resources.
+ *
+ * @param[in] instance UHCI structure to use.
+ */
 void uhci_init_hw(uhci_t *instance)
 {
         assert(instance);
-
-        /* reset everything, who knows what touched it before us */
-        pio_write_16(&instance->registers->usbcmd, UHCI_CMD_GLOBAL_RESET);
+        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(&instance->registers->usbcmd, 0);
-
-        /* reset hc, all states and counters */
-        pio_write_16(&instance->registers->usbcmd, UHCI_CMD_HCRESET);
+        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(&instance->registers->usbcmd) & UHCI_CMD_HCRESET) != 0);
-
-        /* set framelist pointer */
+        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(&instance->registers->flbaseadd, pa);
-
-        /* enable all interrupts, but resume interrupt */
+        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(&instance->registers->usbcmd);
-        usb_log_warning("Previous command value: %x.\n", status);
+        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(&instance->registers->usbcmd,
+        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)
 {
@@ -196 +224 @@
         } else (void) 0
 
-        /* init interrupt code */
+        /* 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");
+        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;
+                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 */
+        /* Init transfer lists */
         ret = uhci_init_transfer_lists(instance);
-        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to initialize transfer lists.\n");
+        CHECK_RET_DEST_CMDS_RETURN(ret, "Failed to init transfer lists.\n");
         usb_log_debug("Initialized transfer lists.\n");
 
-        /* frame list initialization */
+        /* Init USB frame list page*/
         instance->frame_list = get_page();
         ret = instance ? EOK : ENOMEM;
@@ -221 +252 @@
         usb_log_debug("Initialized frame list.\n");
 
-        /* initialize all frames to point to the first queue head */
+        /* Set all frames to point to the first queue head */
         const uint32_t queue =
           instance->transfers_interrupt.queue_head_pa
@@ -231 +262 @@
         }
 
-        /* init address keeper(libusb) */
+        /* Init device keeper*/
         device_keeper_init(&instance->device_manager);
         usb_log_debug("Initialized device manager.\n");
@@ -239 +270 @@
 }
 /*----------------------------------------------------------------------------*/
+/** 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)
 {
@@ -257 +294 @@
         CHECK_RET_CLEAR_RETURN(ret, "Failed to init BULK list.");
 
-        ret = transfer_list_init(&instance->transfers_control_full, "CONTROL_FULL");
+        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");
+        ret = transfer_list_init(
+            &instance->transfers_control_slow, "CONTROL_SLOW");
         CHECK_RET_CLEAR_RETURN(ret, "Failed to init CONTROL SLOW list.");
 
@@ -279 +318 @@
 #endif
 
-        instance->transfers[0][USB_TRANSFER_INTERRUPT] =
+        /* Assign pointers to be used during scheduling */
+        instance->transfers[USB_SPEED_FULL][USB_TRANSFER_INTERRUPT] =
           &instance->transfers_interrupt;
-        instance->transfers[1][USB_TRANSFER_INTERRUPT] =
+        instance->transfers[USB_SPEED_LOW][USB_TRANSFER_INTERRUPT] =
           &instance->transfers_interrupt;
-        instance->transfers[0][USB_TRANSFER_CONTROL] =
+        instance->transfers[USB_SPEED_FULL][USB_TRANSFER_CONTROL] =
           &instance->transfers_control_full;
-        instance->transfers[1][USB_TRANSFER_CONTROL] =
+        instance->transfers[USB_SPEED_LOW][USB_TRANSFER_CONTROL] =
           &instance->transfers_control_slow;
-        instance->transfers[0][USB_TRANSFER_BULK] =
+        instance->transfers[USB_SPEED_FULL][USB_TRANSFER_BULK] =
           &instance->transfers_bulk_full;
 
@@ -294 +334 @@
 }
 /*----------------------------------------------------------------------------*/
+/** 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)
 {
@@ -301 +347 @@
         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",
+                usb_log_warning(
+                    "Invalid USB packet specified %s SPEED %d %zu.\n",
                     low_speed ? "LOW" : "FULL" , batch->transfer_type,
                     batch->max_packet_size);
@@ -316 +363 @@
 }
 /*----------------------------------------------------------------------------*/
+/** 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);
@@ -325 +378 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Polling function, emulates interrupts.
+ *
+ * @param[in] arg UHCI structure to use.
+ * @return EOK
+ */
 int uhci_interrupt_emulator(void* arg)
 {
@@ -343 +401 @@
 }
 /*---------------------------------------------------------------------------*/
+/** Debug function, checks consistency of memory structures.
+ *
+ * @param[in] arg UHCI structure to use.
+ * @return EOK
+ */
 int uhci_debug_checker(void *arg)
 {
@@ -401 +464 @@
                 async_usleep(UHCI_DEBUGER_TIMEOUT);
         }
-        return 0;
+        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)

uspace/drv/uhci-hcd/uhci.h

@@ -84 +84 @@
         device_keeper_t device_manager;
 
-        volatile regs_t *registers;
+        regs_t *registers;
 
         link_pointer_t *frame_list;

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

@@ -71 +71 @@
 }
 
-static inline void queue_head_element_td(queue_head_t *instance, uint32_t pa)
+static inline void queue_head_set_element_td(queue_head_t *instance, uint32_t pa)
 {
         if (pa) {
@@ -78 +78 @@
 }
 
-static inline queue_head_t * queue_head_get() {
-        queue_head_t *ret = malloc32(sizeof(queue_head_t));
-        if (ret)
-                queue_head_init(ret);
-        return ret;
-}
-
-static inline void queue_head_dispose(queue_head_t *head)
-        { free32(head); }
-
-
 #endif
 /**

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

@@ -38 +38 @@
 #include "utils/malloc32.h"
 
+/** Initializes Transfer Descriptor
+ *
+ * @param[in] instance Memory place to initialize.
+ * @param[in] err_count Number of retries hc should attempt.
+ * @param[in] size Size of data source.
+ * @param[in] toggle Value of toggle bit.
+ * @param[in] iso True if TD is for Isochronous transfer.
+ * @param[in] low_speed Target device's speed.
+ * @param[in] target Address and endpoint receiving the transfer.
+ * @param[in] pid Packet identification (SETUP, IN or OUT).
+ * @param[in] buffer Source of data.
+ * @param[in] next Net TD in transaction.
+ * @return Error code.
+ */
 void td_init(td_t *instance, int err_count, size_t size, bool toggle, bool iso,
-    bool low_speed, usb_target_t target, usb_packet_id pid, void *buffer, td_t *next)
+    bool low_speed, usb_target_t target, usb_packet_id pid, void *buffer,
+    td_t *next)
 {
         assert(instance);
         assert(size < 1024);
-        assert((pid == USB_PID_SETUP) || (pid == USB_PID_IN) || (pid == USB_PID_OUT));
+        assert((pid == USB_PID_SETUP) || (pid == USB_PID_IN)
+            || (pid == USB_PID_OUT));
 
         instance->next = 0
@@ -81 +97 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Converts TD status into standard error code
+ *
+ * @param[in] instance TD structure to use.
+ * @return Error code.
+ */
 int td_status(td_t *instance)
 {

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

@@ -39 +39 @@
 
 /*----------------------------------------------------------------------------*/
+/** Initializes device keeper structure.
+ *
+ * @param[in] instance Memory place to initialize.
+ */
 void device_keeper_init(device_keeper_t *instance)
 {
@@ -53 +57 @@
 }
 /*----------------------------------------------------------------------------*/
-void device_keeper_reserve_default(
-    device_keeper_t *instance, usb_speed_t speed)
+/** Attempts to obtain address 0, blocks.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] speed Speed of the device requesting default address.
+ */
+void device_keeper_reserve_default(device_keeper_t *instance, usb_speed_t speed)
 {
         assert(instance);
@@ -67 +75 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Attempts to obtain address 0, blocks.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] speed Speed of the device requesting default address.
+ */
 void device_keeper_release_default(device_keeper_t *instance)
 {
@@ -76 +89 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Checks setup 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.
+ */
 void device_keeper_reset_if_need(
     device_keeper_t *instance, usb_target_t target, const unsigned char *data)
@@ -84 +103 @@
             || target.address >= USB_ADDRESS_COUNT || target.address < 0
             || !instance->devices[target.address].occupied) {
-                goto the_end;
+                fibril_mutex_unlock(&instance->guard);
+                return;
         }
 
@@ -90 +110 @@
         {
         case 0x01: /*clear feature*/
-                /* recipient is enpoint, value is zero (ENDPOINT_STALL) */
+                /* recipient is endpoint, value is zero (ENDPOINT_STALL) */
                 if (((data[0] & 0xf) == 1) && ((data[2] | data[3]) == 0)) {
-                        /* enpoint number is < 16, thus first byte is enough */
-                        instance->devices[target.address].toggle_status &= ~(1 << data[4]);
+                        /* endpoint number is < 16, thus first byte is enough */
+                        instance->devices[target.address].toggle_status &=
+                            ~(1 << data[4]);
                 }
         break;
@@ -102 +123 @@
         break;
         }
-the_end:
-        fibril_mutex_unlock(&instance->guard);
-}
-/*----------------------------------------------------------------------------*/
+        fibril_mutex_unlock(&instance->guard);
+}
+/*----------------------------------------------------------------------------*/
+/** Gets current value of endpoint toggle.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] target Device and endpoint used.
+ * @return Error code
+ */
 int device_keeper_get_toggle(device_keeper_t *instance, usb_target_t target)
 {
@@ -116 +142 @@
                 ret = EINVAL;
         } else {
-                ret = (instance->devices[target.address].toggle_status >> target.endpoint) & 1;
+                ret =
+                    (instance->devices[target.address].toggle_status
+                        >> target.endpoint) & 1;
         }
         fibril_mutex_unlock(&instance->guard);
@@ -122 +150 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Sets 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.
+ * @return Error code.
+ */
 int device_keeper_set_toggle(
     device_keeper_t *instance, usb_target_t target, bool toggle)
@@ -144 +179 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Gets a free USB address
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] speed Speed of the device requiring address.
+ * @return Free address, or error code.
+ */
 usb_address_t device_keeper_request(
     device_keeper_t *instance, usb_speed_t speed)
@@ -171 +212 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Binds USB address to devman handle.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] address Device address
+ * @param[in] handle Devman handle of the device.
+ */
 void device_keeper_bind(
     device_keeper_t *instance, usb_address_t address, devman_handle_t handle)
@@ -183 +230 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Releases used USB address.
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] address Device address
+ */
 void device_keeper_release(device_keeper_t *instance, usb_address_t address)
 {
@@ -195 +247 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Finds USB address associated with the device
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] handle Devman handle of the device seeking its address.
+ * @return USB Address, or error code.
+ */
 usb_address_t device_keeper_find(
     device_keeper_t *instance, devman_handle_t handle)
@@ -212 +270 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Gets speed associated with the address
+ *
+ * @param[in] instance Device keeper structure to use.
+ * @param[in] address Address of the device.
+ * @return USB speed.
+ */
 usb_speed_t device_keeper_speed(
     device_keeper_t *instance, usb_address_t address)

uspace/drv/uhci-rhd/main.c

@@ -35 +35 @@
 #include <devman.h>
 #include <device/hw_res.h>
+#include <errno.h>
 #include <usb_iface.h>
 #include <usb/ddfiface.h>
+#include <usb/debug.h>
 
-#include <errno.h>
 
-#include <usb/debug.h>
 
 #include "root_hub.h"
@@ -47 +47 @@
 static int hc_get_my_registers(ddf_dev_t *dev,
     uintptr_t *io_reg_address, size_t *io_reg_size);
-
+/*----------------------------------------------------------------------------*/
 static int usb_iface_get_hc_handle(ddf_fun_t *fun, devman_handle_t *handle)
 {
@@ -58 +58 @@
         return EOK;
 }
-
+/*----------------------------------------------------------------------------*/
 static usb_iface_t uhci_rh_usb_iface = {
         .get_hc_handle = usb_iface_get_hc_handle,
         .get_address = usb_iface_get_address_hub_impl
 };
-
+/*----------------------------------------------------------------------------*/
 static ddf_dev_ops_t uhci_rh_ops = {
         .interfaces[USB_DEV_IFACE] = &uhci_rh_usb_iface,
 };
-
+/*----------------------------------------------------------------------------*/
+/** Initializes a new ddf driver instance of UHCI root hub.
+ *
+ * @param[in] device DDF instance of the device to initialize.
+ * @return Error code.
+ */
 static int uhci_rh_add_device(ddf_dev_t *device)
 {
@@ -104 +109 @@
         return EOK;
 }
-
+/*----------------------------------------------------------------------------*/
 static driver_ops_t uhci_rh_driver_ops = {
         .add_device = uhci_rh_add_device,
 };
-
+/*----------------------------------------------------------------------------*/
 static driver_t uhci_rh_driver = {
         .name = NAME,
@@ -114 +119 @@
 };
 /*----------------------------------------------------------------------------*/
+/** Initializes global driver structures (NONE).
+ *
+ * @param[in] argc Nmber of arguments in argv vector (ignored).
+ * @param[in] argv Cmdline argument vector (ignored).
+ * @return Error code.
+ *
+ * Driver debug level is set here.
+ */
 int main(int argc, char *argv[])
 {
@@ -120 +133 @@
 }
 /*----------------------------------------------------------------------------*/
-int hc_get_my_registers(ddf_dev_t *dev,
-    uintptr_t *io_reg_address, size_t *io_reg_size)
+/** Get address of I/O registers.
+ *
+ * @param[in] dev Device asking for the addresses.
+ * @param[out] io_reg_address Base address of the memory range.
+ * @param[out] io_reg_size Size of the memory range.
+ * @return Error code.
+ */
+int hc_get_my_registers(
+    ddf_dev_t *dev, uintptr_t *io_reg_address, size_t *io_reg_size)
 {
         assert(dev != NULL);
@@ -146 +166 @@
         for (i = 0; i < hw_resources.count; i++) {
                 hw_resource_t *res = &hw_resources.resources[i];
-                switch (res->type) {
-                        case IO_RANGE:
-                                io_address = (uintptr_t)
-                                    res->res.io_range.address;
-                                io_size = res->res.io_range.size;
-                                io_found = true;
-                                break;
-                        default:
-                                break;
+                switch (res->type)
+                {
+                case IO_RANGE:
+                        io_address = (uintptr_t) res->res.io_range.address;
+                        io_size = res->res.io_range.size;
+                        io_found = true;
+
+                default:
+                        break;
                 }
         }
@@ -170 +190 @@
         }
         rc = EOK;
+
 leave:
         async_hangup(parent_phone);
-
         return rc;
 }

uspace/drv/uhci-rhd/port.c

@@ -46 +46 @@
 #include "port_status.h"
 
-static int uhci_port_new_device(uhci_port_t *port, uint16_t status);
+static int uhci_port_new_device(uhci_port_t *port, usb_speed_t speed);
 static int uhci_port_remove_device(uhci_port_t *port);
 static int uhci_port_set_enabled(uhci_port_t *port, bool enabled);
 static int uhci_port_check(void *port);
-static int new_device_enable_port(int portno, void *arg);
-
-int uhci_port_init(
-  uhci_port_t *port, port_status_t *address, unsigned number,
-  unsigned usec, ddf_dev_t *rh)
+static int uhci_port_reset_enable(int portno, void *arg);
+/*----------------------------------------------------------------------------*/
+/** Initializes UHCI root hub port instance.
+ *
+ * @param[in] port Memory structure to use.
+ * @param[in] addr Address of I/O register.
+ * @param[in] number Port number.
+ * @param[in] usec Polling interval.
+ * @param[in] rh Pointer to ddf instance fo the root hub driver.
+ * @return Error code.
+ *
+ * Starts the polling fibril.
+ */
+int uhci_port_init(uhci_port_t *port,
+    port_status_t *address, unsigned number, unsigned usec, ddf_dev_t *rh)
 {
         assert(port);
+
         port->address = address;
         port->number = number;
@@ -62 +73 @@
         port->attached_device = 0;
         port->rh = rh;
+
         int rc = usb_hc_connection_initialize_from_device(
             &port->hc_connection, rh);
@@ -75 +87 @@
                 return ENOMEM;
         }
+
         fibril_add_ready(port->checker);
         usb_log_debug("Port(%p - %d): Added fibril. %x\n",
@@ -81 +94 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Finishes UHCI root hub port instance.
+ *
+ * @param[in] port Memory structure to use.
+ *
+ * Stops the polling fibril.
+ */
 void uhci_port_fini(uhci_port_t *port)
 {
-// TODO: destroy fibril
-// TODO: hangup phone
-//      fibril_teardown(port->checker);
+        /* TODO: Kill fibril here */
         return;
 }
 /*----------------------------------------------------------------------------*/
+/** Periodically checks port status and reports new devices.
+ *
+ * @param[in] port Memory structure to use.
+ * @return Error code.
+ */
 int uhci_port_check(void *port)
 {
-        uhci_port_t *port_instance = port;
-        assert(port_instance);
-//      port_status_write(port_instance->address, 0);
-
+        uhci_port_t *instance = port;
+        assert(instance);
+
+        /* Iteration count, for debug purposes only */
         unsigned count = 0;
 
         while (1) {
-                async_usleep(port_instance->wait_period_usec);
+                async_usleep(instance->wait_period_usec);
 
                 /* read register value */
-                port_status_t port_status =
-                        port_status_read(port_instance->address);
-
-                /* debug print */
-                static fibril_mutex_t dbg_mtx = FIBRIL_MUTEX_INITIALIZER(dbg_mtx);
+                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",
-                  port_instance->address, port_instance->number, port_status, count++);
+                  instance->address, instance->number, port_status, count++);
 //              print_port_status(port_status);
                 fibril_mutex_unlock(&dbg_mtx);
 
-                if ((port_status & STATUS_CONNECTED_CHANGED) != 0) {
-                        usb_log_debug("Port(%p - %d): Connected change detected: %x.\n",
-                            port_instance->address, port_instance->number, port_status);
-
-
-                        int rc = usb_hc_connection_open(
-                            &port_instance->hc_connection);
-                        if (rc != EOK) {
-                                usb_log_error("Port(%p - %d): Failed to connect to HC.",
-                                    port_instance->address, port_instance->number);
-                                continue;
-                        }
-
-                        /* remove any old device */
-                        if (port_instance->attached_device) {
-                                usb_log_debug("Port(%p - %d): Removing device.\n",
-                                    port_instance->address, port_instance->number);
-                                uhci_port_remove_device(port_instance);
-                        }
-
-                        if ((port_status & STATUS_CONNECTED) != 0) {
-                                /* new device */
-                                uhci_port_new_device(port_instance, port_status);
-                        } else {
-                                /* ack changes by writing one to WC bits */
-                                port_status_write(port_instance->address, port_status);
-                                usb_log_debug("Port(%p - %d): Change status ACK.\n",
-                                                port_instance->address, port_instance->number);
-                        }
-
-                        rc = usb_hc_connection_close(
-                            &port_instance->hc_connection);
-                        if (rc != EOK) {
-                                usb_log_error("Port(%p - %d): Failed to disconnect from HC.",
-                                    port_instance->address, port_instance->number);
-                        }
-                }
-        }
-        return EOK;
-}
-
+                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);
+
+                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);
+                        continue;
+                }
+
+                /* Remove any old device */
+                if (instance->attached_device) {
+                        usb_log_debug2("Port(%p - %d): Removing device.\n",
+                            instance->address, instance->number);
+                        uhci_port_remove_device(instance);
+                }
+
+                if ((port_status & STATUS_CONNECTED) != 0) {
+                        /* New device */
+                        const usb_speed_t speed =
+                            ((port_status & STATUS_LOW_SPEED) != 0) ?
+                            USB_SPEED_LOW : USB_SPEED_FULL;
+                        uhci_port_new_device(instance, speed);
+                } 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);
+                }
+
+                rc = usb_hc_connection_close(&instance->hc_connection);
+                if (rc != EOK) {
+                        usb_log_error("Port(%p - %d): Failed to disconnect.",
+                            instance->address, instance->number);
+                }
+        }
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
 /** Callback for enabling port during adding a new device.
  *
@@ -159 +183 @@
  * @return Error code.
  */
-static int new_device_enable_port(int portno, void *arg)
+int uhci_port_reset_enable(int portno, void *arg)
 {
         uhci_port_t *port = (uhci_port_t *) arg;
@@ -184 +208 @@
                 port_status_write(port->address, port_status);
                 async_usleep(10000);
-                port_status =
-                        port_status_read(port->address);
+                port_status = port_status_read(port->address);
                 port_status &= ~STATUS_IN_RESET;
                 port_status_write(port->address, port_status);
@@ -194 +217 @@
         /* Enable the port. */
         uhci_port_set_enabled(port, true);
-
-        return EOK;
-}
-
-/*----------------------------------------------------------------------------*/
-static int uhci_port_new_device(uhci_port_t *port, uint16_t status)
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Initializes and reports connected device.
+ *
+ * @param[in] port Memory structure to use.
+ * @param[in] speed Detected speed.
+ * @return Error code.
+ *
+ * Uses libUSB function to do the actual work.
+ */
+int uhci_port_new_device(uhci_port_t *port, usb_speed_t speed)
 {
         assert(port);
@@ -209 +238 @@
         usb_address_t dev_addr;
         int rc = usb_hc_new_device_wrapper(port->rh, &port->hc_connection,
-            ((status & STATUS_LOW_SPEED) != 0) ? USB_SPEED_LOW : USB_SPEED_FULL,
-            new_device_enable_port, port->number, port,
+            speed, uhci_port_reset_enable, port->number, port,
             &dev_addr, &port->attached_device, NULL, NULL, NULL);
 
         if (rc != EOK) {
-                usb_log_error("Port(%p-%d): Failed(%d) adding new device: %s.\n",
+                usb_log_error("Port(%p-%d): Failed(%d) to add device: %s.\n",
                     port->address, port->number, rc, str_error(rc));
                 uhci_port_set_enabled(port, false);
@@ -225 +253 @@
         return EOK;
 }
-
-/*----------------------------------------------------------------------------*/
-static int uhci_port_remove_device(uhci_port_t *port)
+/*----------------------------------------------------------------------------*/
+/** Removes device.
+ *
+ * @param[in] port Memory structure to use.
+ * @return Error code.
+ *
+ * Does not work DDF does not support device removal.
+ */
+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);
-//      uhci_port_set_enabled(port, false);
-        return EOK;
-}
-/*----------------------------------------------------------------------------*/
-static int uhci_port_set_enabled(uhci_port_t *port, bool enabled)
+            port->address, port->number, (unsigned int)port->attached_device);
+        return EOK;
+}
+/*----------------------------------------------------------------------------*/
+/** Enables and disables port.
+ *
+ * @param[in] port Memory structure to use.
+ * @return Error code. (Always EOK)
+ */
+int uhci_port_set_enabled(uhci_port_t *port, bool enabled)
 {
         assert(port);
 
-        /* read register value */
-        port_status_t port_status
-                = port_status_read(port->address);
-
-        /* enable port: register write */
+        /* Read register value */
+        port_status_t port_status = port_status_read(port->address);
+
+        /* Set enabled bit */
         if (enabled) {
                 port_status |= STATUS_ENABLED;
@@ -249 +286 @@
                 port_status &= ~STATUS_ENABLED;
         }
+
+        /* Write new value. */
         port_status_write(port->address, port_status);
 

uspace/drv/uhci-rhd/port_status.c

@@ -60 +60 @@
 };
 
+/** Prints portr status in a human readable way.
+ *
+ * @param[in] value Port value to print.
+ * @return Error code.
+ */
 void print_port_status(port_status_t value)
 {

uspace/drv/uhci-rhd/root_hub.c

@@ -40 +40 @@
 #include "root_hub.h"
 
+/** Initializes 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.
+ * @return Error code.
+ */
 int uhci_root_hub_init(
   uhci_root_hub_t *instance, void *addr, size_t size, ddf_dev_t *rh)
@@ -47 +55 @@
         int ret;
 
-        /* allow access to root hub registers */
-        assert(sizeof(port_status_t) * UHCI_ROOT_HUB_PORT_COUNT == size);
+        /* Allow access to root hub port registers */
+        assert(sizeof(port_status_t) * UHCI_ROOT_HUB_PORT_COUNT <= size);
         port_status_t *regs;
         ret = pio_enable(addr, size, (void**)&regs);
-
         if (ret < 0) {
-                usb_log_error("Failed to gain access to port registers at %p\n", regs);
+                usb_log_error(
+                    "Failed to gain access to port registers at %p\n", regs);
                 return ret;
         }
@@ -60 +68 @@
         unsigned i = 0;
         for (; i < UHCI_ROOT_HUB_PORT_COUNT; ++i) {
-                /* mind pointer arithmetics */
+                /* NOTE: mind pointer arithmetics here */
                 ret = uhci_port_init(
-                  &instance->ports[i], regs + i, i, ROOT_HUB_WAIT_USEC, rh);
+                    &instance->ports[i], regs + i, i, ROOT_HUB_WAIT_USEC, rh);
                 if (ret != EOK) {
                         unsigned j = 0;
@@ -74 +82 @@
 }
 /*----------------------------------------------------------------------------*/
-int uhci_root_hub_fini( uhci_root_hub_t* instance )
+/** Finishes UHCI root hub instance.
+ *
+ * @param[in] instance Driver memory structure to use.
+ * @return Error code.
+ */
+int uhci_root_hub_fini(uhci_root_hub_t* instance)
 {
-        assert( instance );
-        // TODO:
-        //destroy fibril here
-        //disable access to registers
+        assert(instance);
+        unsigned i = 0;
+        for (; i < UHCI_ROOT_HUB_PORT_COUNT; ++i) {
+                uhci_port_fini(&instance->ports[i]);
+        }
         return EOK;
 }