Changeset b39eb79 in mainline for uspace/drv/bus

Timestamp:

2011-12-26T17:21:21Z (14 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

9b56a8dd

Parents:

cf5c05c0 (diff), 7e1b130 (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:

Mainline changes.

Location:

uspace/drv/bus

Files:

• isa/Makefile (modified) (2 diffs)
• isa/i8237.c (added)
• isa/i8237.h (moved) (moved from uspace/lib/usbdev/src/pipepriv.h ) (2 diffs)
• isa/isa.c (modified) (10 diffs)
• isa/isa.dev (modified) (1 diff)
• pci/pciintel/pci.c (modified) (1 diff)
• usb/ohci/hc.c (modified) (3 diffs)
• usb/ohci/ohci.c (modified) (2 diffs)
• usb/ohci/ohci_batch.c (modified) (12 diffs)
• usb/ohci/ohci_batch.h (modified) (2 diffs)
• usb/ohci/pci.c (modified) (3 diffs)
• usb/ohci/root_hub.c (modified) (20 diffs)
• usb/ohci/utils/malloc32.h (modified) (1 diff)
• usb/uhci/hc.c (modified) (1 diff)
• usb/uhci/pci.c (modified) (3 diffs)
• usb/uhci/transfer_list.c (modified) (1 diff)
• usb/uhci/uhci.c (modified) (3 diffs)
• usb/uhci/uhci_batch.c (modified) (7 diffs)
• usb/uhci/uhci_batch.h (modified) (3 diffs)
• usb/uhci/utils/malloc32.h (modified) (2 diffs)
• usb/uhcirh/main.c (modified) (3 diffs)
• usb/uhcirh/port.c (modified) (2 diffs)
• usb/usbhub/port.c (modified) (2 diffs)
• usb/usbhub/usbhub.c (modified) (7 diffs)
• usb/usbhub/usbhub.h (modified) (1 diff)
• usb/usbmast/main.c (modified) (1 diff)
• usb/usbmid/main.c (modified) (1 diff)
• usb/vhc/hub.c (modified) (1 diff)

uspace/drv/bus/isa/Makefile

@@ -1 +1 @@
 #
 # Copyright (c) 2010 Lenka Trochtova
+# Copyright (c) 2011 Jan Vesely
 # All rights reserved.
 #
@@ -33 +34 @@
 
 SOURCES = \
+        i8237.c \
         isa.c
 

uspace/drv/bus/isa/i8237.h

@@ -1 +1 @@
 /*
- * Copyright (c) 2011 Vojtech Horky
+ * Copyright (c) 2011 Jan Vesely
  * All rights reserved.
  *
@@ -27 +27 @@
  */
 
-/** @addtogroup libusbdev
+/** @addtogroup isa
  * @{
  */
+
 /** @file
- * Library internal functions on USB pipes.
+ * @brief DMA memory management
  */
-#ifndef LIBUSBDEV_PIPEPRIV_H_
-#define LIBUSBDEV_PIPEPRIV_H_
 
-#include <usb/dev/pipes.h>
-#include <bool.h>
+#ifndef DRV_BUS_ISA_I8237_H
+#define DRV_BUS_ISA_I8237_H
 
-void pipe_acquire(usb_pipe_t *);
-void pipe_release(usb_pipe_t *);
-
-void pipe_start_transaction(usb_pipe_t *);
-void pipe_end_transaction(usb_pipe_t *);
-
-int pipe_add_ref(usb_pipe_t *, bool);
-void pipe_drop_ref(usb_pipe_t *);
-
+extern int dma_setup_channel(unsigned int, uint32_t, uint16_t, uint8_t);
 
 #endif
+
 /**
  * @}

uspace/drv/bus/isa/isa.c

@@ -2 +2 @@
  * Copyright (c) 2010 Lenka Trochtova
  * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2011 Jan Vesely
  * All rights reserved.
  *
@@ -56 +57 @@
 #include <ns.h>
 #include <sys/stat.h>
+#include <ipc/irc.h>
+#include <ipc/services.h>
+#include <sysinfo.h>
+#include <ns.h>
 
 #include <ddf/driver.h>
@@ -65 +70 @@
 #include <device/hw_res.h>
 
+#include "i8237.h"
+
 #define NAME "isa"
 #define CHILD_FUN_CONF_PATH "/drv/isa/isa.dev"
@@ -74 +81 @@
 #define ISA_FUN(fun) ((isa_fun_t *) ((fun)->driver_data))
 
-#define ISA_MAX_HW_RES 4
+#define ISA_MAX_HW_RES 5
 
 typedef struct {
@@ -141 +148 @@
 }
 
+static int isa_dma_channel_fun_setup(ddf_fun_t *fnode,
+    unsigned int channel, uint32_t pa, uint16_t size, uint8_t mode)
+{
+        assert(fnode);
+        isa_fun_t *isa_fun = fnode->driver_data;
+        const hw_resource_list_t *res = &isa_fun->hw_resources;
+        assert(res);
+        
+        const unsigned int ch = channel;
+        for (size_t i = 0; i < res->count; ++i) {
+                if (((res->resources[i].type == DMA_CHANNEL_16) &&
+                    (res->resources[i].res.dma_channel.dma16 == ch)) ||
+                    ((res->resources[i].type == DMA_CHANNEL_8) &&
+                    (res->resources[i].res.dma_channel.dma8 == ch))) {
+                        return dma_setup_channel(channel, pa, size, mode);
+                }
+        }
+        
+        return EINVAL;
+}
+
 static hw_res_ops_t isa_fun_hw_res_ops = {
-        &isa_get_fun_resources,
-        &isa_enable_fun_interrupt
+        .get_resource_list = isa_get_fun_resources,
+        .enable_interrupt = isa_enable_fun_interrupt,
+        .dma_channel_setup = isa_dma_channel_fun_setup,
 };
 
@@ -314 +343 @@
 }
 
+static void isa_fun_set_dma(isa_fun_t *fun, int dma)
+{
+        size_t count = fun->hw_resources.count;
+        hw_resource_t *resources = fun->hw_resources.resources;
+        
+        if (count < ISA_MAX_HW_RES) {
+                if ((dma > 0) && (dma < 4)) {
+                        resources[count].type = DMA_CHANNEL_8;
+                        resources[count].res.dma_channel.dma8 = dma;
+                        
+                        fun->hw_resources.count++;
+                        ddf_msg(LVL_NOTE, "Added dma 0x%x to function %s", dma,
+                            fun->fnode->name);
+                        
+                        return;
+                }
+
+                if ((dma > 4) && (dma < 8)) {
+                        resources[count].type = DMA_CHANNEL_16;
+                        resources[count].res.dma_channel.dma16 = dma;
+                        
+                        fun->hw_resources.count++;
+                        ddf_msg(LVL_NOTE, "Added dma 0x%x to function %s", dma,
+                            fun->fnode->name);
+                        
+                        return;
+                }
+                
+                ddf_msg(LVL_WARN, "Skipped dma 0x%x for function %s", dma,
+                    fun->fnode->name);
+        }
+}
+
 static void isa_fun_set_io_range(isa_fun_t *fun, size_t addr, size_t len)
 {
@@ -343 +405 @@
         if (val != end)
                 isa_fun_set_irq(fun, irq);
+}
+
+static void fun_parse_dma(isa_fun_t *fun, char *val)
+{
+        unsigned int dma = 0;
+        char *end = NULL;
+        
+        val = skip_spaces(val);
+        dma = (unsigned int) strtol(val, &end, 10);
+        
+        if (val != end)
+                isa_fun_set_dma(fun, dma);
 }
 
@@ -436 +510 @@
         if (!prop_parse(fun, line, "io_range", &fun_parse_io_range) &&
             !prop_parse(fun, line, "irq", &fun_parse_irq) &&
+            !prop_parse(fun, line, "dma", &fun_parse_dma) &&
             !prop_parse(fun, line, "match", &fun_parse_match_id)) {
 
@@ -446 +521 @@
 {
         fun->hw_resources.resources =
-            (hw_resource_t *)malloc(sizeof(hw_resource_t) * ISA_MAX_HW_RES);
+            (hw_resource_t *) malloc(sizeof(hw_resource_t) * ISA_MAX_HW_RES);
 }
 
@@ -630 +705 @@
 
 
-static void isa_init() 
+static void isa_init()
 {
         ddf_log_init(NAME, LVL_ERROR);

uspace/drv/bus/isa/isa.dev

@@ -15 +15 @@
         io_range 060 5
         
+
+ne2k:
+        match 100 isa/ne2k
+        irq 5
+        io_range 300 20
+
+sb16:
+        match 100 isa/sb16
+        io_range 220 20
+        io_range 330 2
+        irq 5
+        dma 1
+        dma 5

uspace/drv/bus/pci/pciintel/pci.c

@@ -187 +187 @@
 
 static hw_res_ops_t pciintel_hw_res_ops = {
-        &pciintel_get_resources,
-        &pciintel_enable_interrupt
+        .get_resource_list = &pciintel_get_resources,
+        .enable_interrupt = &pciintel_enable_interrupt,
 };
 

uspace/drv/bus/usb/ohci/hc.c

@@ -137 +137 @@
                 return ret;
         }
-        usb_device_manager_bind_address(&instance->generic.dev_manager,
-            instance->rh.address, hub_fun->handle);
 
 #define CHECK_RET_UNREG_RETURN(ret, message...) \
@@ -150 +148 @@
         return ret; \
 } else (void)0
+
         ret = usb_endpoint_manager_add_ep(
             &instance->generic.ep_manager, instance->rh.address, 0,
@@ -165 +164 @@
         CHECK_RET_UNREG_RETURN(ret,
             "Failed to bind root hub function: %s.\n", str_error(ret));
+
+        ret = usb_device_manager_bind_address(&instance->generic.dev_manager,
+            instance->rh.address, hub_fun->handle);
+        if (ret != EOK)
+                usb_log_warning("Failed to bind root hub address: %s.\n",
+                    str_error(ret));
 
         return EOK;

uspace/drv/bus/usb/ohci/ohci.c

@@ -140 +140 @@
 int device_setup_ohci(ddf_dev_t *device)
 {
-        assert(device);
-
-        ohci_t *instance = malloc(sizeof(ohci_t));
+        if (device == NULL)
+                return EBADMEM;
+
+        ohci_t *instance = ddf_dev_data_alloc(device,sizeof(ohci_t));
         if (instance == NULL) {
                 usb_log_error("Failed to allocate OHCI driver.\n");
                 return ENOMEM;
         }
-        instance->rh_fun = NULL;
-        instance->hc_fun = NULL;
 
 #define CHECK_RET_DEST_FREE_RETURN(ret, message...) \
 if (ret != EOK) { \
         if (instance->hc_fun) { \
+                instance->hc_fun->driver_data = NULL; \
                 ddf_fun_destroy(instance->hc_fun); \
         } \
         if (instance->rh_fun) { \
+                instance->rh_fun->driver_data = NULL; \
                 ddf_fun_destroy(instance->rh_fun); \
         } \
-        free(instance); \
         usb_log_error(message); \
         return ret; \
@@ -219 +219 @@
             "Failed to init ohci_hcd: %s.\n", str_error(ret));
 
-        device->driver_data = instance;
-
 #define CHECK_RET_FINI_RETURN(ret, message...) \
 if (ret != EOK) { \

uspace/drv/bus/usb/ohci/ohci_batch.c

@@ -34 +34 @@
 #include <errno.h>
 #include <str_error.h>
+#include <macros.h>
 
 #include <usb/usb.h>
@@ -53 +54 @@
                 return;
         if (ohci_batch->tds) {
+                const ohci_endpoint_t *ohci_ep =
+                    ohci_endpoint_get(ohci_batch->usb_batch->ep);
+                assert(ohci_ep);
                 for (unsigned i = 0; i < ohci_batch->td_count; ++i) {
-                        if (i != ohci_batch->leave_td)
+                        if (ohci_batch->tds[i] != ohci_ep->td)
                                 free32(ohci_batch->tds[i]);
                 }
@@ -64 +68 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Finishes usb_transfer_batch and destroys the structure.
+ *
+ * @param[in] uhci_batch Instance to finish and destroy.
+ */
 void ohci_transfer_batch_finish_dispose(ohci_transfer_batch_t *ohci_batch)
 {
@@ -69 +77 @@
         assert(ohci_batch->usb_batch);
         usb_transfer_batch_finish(ohci_batch->usb_batch,
-            ohci_batch->device_buffer + ohci_batch->usb_batch->setup_size,
-            ohci_batch->usb_batch->buffer_size);
+            ohci_batch->device_buffer + ohci_batch->usb_batch->setup_size);
         ohci_transfer_batch_dispose(ohci_batch);
 }
 /*----------------------------------------------------------------------------*/
+/** Allocate memory and initialize internal data structure.
+ *
+ * @param[in] usb_batch Pointer to generic USB batch structure.
+ * @return Valid pointer if all structures were successfully created,
+ * NULL otherwise.
+ *
+ * Determines the number of needed transfer descriptors (TDs).
+ * Prepares a transport buffer (that is accessible by the hardware).
+ * Initializes parameters needed for the transfer and callback.
+ */
 ohci_transfer_batch_t * ohci_transfer_batch_get(usb_transfer_batch_t *usb_batch)
 {
@@ -105 +122 @@
         ohci_batch->ed = ohci_endpoint_get(usb_batch->ep)->ed;
         ohci_batch->tds[0] = ohci_endpoint_get(usb_batch->ep)->td;
-        ohci_batch->leave_td = 0;
 
         for (unsigned i = 1; i <= ohci_batch->td_count; ++i) {
@@ -152 +168 @@
  * completes with the last TD.
  */
-bool ohci_transfer_batch_is_complete(ohci_transfer_batch_t *ohci_batch)
+bool ohci_transfer_batch_is_complete(const ohci_transfer_batch_t *ohci_batch)
 {
         assert(ohci_batch);
@@ -174 +190 @@
 
         /* Assume we will leave the last(unused) TD behind */
-        ohci_batch->leave_td = ohci_batch->td_count;
+        unsigned leave_td = ohci_batch->td_count;
 
         /* Check all TDs */
@@ -212 +228 @@
                          * It will be the one TD we leave behind.
                          */
-                        ohci_batch->leave_td = i + 1;
+                        leave_td = i + 1;
 
                         /* Check TD assumption */
-                        const uint32_t pa = addr_to_phys(
-                            ohci_batch->tds[ohci_batch->leave_td]);
-                        assert((ohci_batch->ed->td_head & ED_TDTAIL_PTR_MASK)
+                        const uint32_t pa =
+                            addr_to_phys(ohci_batch->tds[leave_td]);
+                        assert((ohci_batch->ed->td_head & ED_TDHEAD_PTR_MASK)
                             == pa);
 
                         ed_set_tail_td(ohci_batch->ed,
-                            ohci_batch->tds[ohci_batch->leave_td]);
+                            ohci_batch->tds[leave_td]);
 
                         /* Clear possible ED HALT */
@@ -234 +250 @@
         ohci_endpoint_t *ohci_ep = ohci_endpoint_get(ohci_batch->usb_batch->ep);
         assert(ohci_ep);
-        ohci_ep->td = ohci_batch->tds[ohci_batch->leave_td];
+        ohci_ep->td = ohci_batch->tds[leave_td];
 
         /* Make sure that we are leaving the right TD behind */
@@ -248 +264 @@
  * @param[in] ohci_batch Batch structure to use
  */
-void ohci_transfer_batch_commit(ohci_transfer_batch_t *ohci_batch)
+void ohci_transfer_batch_commit(const ohci_transfer_batch_t *ohci_batch)
 {
         assert(ohci_batch);
@@ -295 +311 @@
         while (remain_size > 0) {
                 const size_t transfer_size =
-                    remain_size > OHCI_TD_MAX_TRANSFER ?
-                    OHCI_TD_MAX_TRANSFER : remain_size;
+                    min(remain_size, OHCI_TD_MAX_TRANSFER);
                 toggle = 1 - toggle;
 
@@ -378 +393 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Transfer setup table. */
 static void (*const batch_setup[])(ohci_transfer_batch_t*, usb_direction_t) =
 {

uspace/drv/bus/usb/ohci/ohci_batch.h

@@ -53 +53 @@
         /** Number of TDs used by the transfer */
         size_t td_count;
-        /** Dummy TD to be left at the ED and used by the next transfer */
-        size_t leave_td;
         /** Data buffer, must be accessible by the OHCI hw. */
         char *device_buffer;
@@ -62 +60 @@
 
 ohci_transfer_batch_t * ohci_transfer_batch_get(usb_transfer_batch_t *batch);
-bool ohci_transfer_batch_is_complete(ohci_transfer_batch_t *batch);
-void ohci_transfer_batch_commit(ohci_transfer_batch_t *batch);
+bool ohci_transfer_batch_is_complete(const ohci_transfer_batch_t *batch);
+void ohci_transfer_batch_commit(const ohci_transfer_batch_t *batch);
 void ohci_transfer_batch_finish_dispose(ohci_transfer_batch_t *batch);
 /*----------------------------------------------------------------------------*/

uspace/drv/bus/usb/ohci/pci.c

@@ -42 +42 @@
 #include <ddi.h>
 #include <libarch/ddi.h>
-#include <device/hw_res.h>
+#include <device/hw_res_parsed.h>
 
 #include <usb/debug.h>
@@ -61 +61 @@
 {
         assert(dev);
-        assert(mem_reg_address);
-        assert(mem_reg_size);
-        assert(irq_no);
 
         async_sess_t *parent_sess =
@@ -71 +68 @@
                 return ENOMEM;
 
-        hw_resource_list_t hw_resources;
-        int rc = hw_res_get_resource_list(parent_sess, &hw_resources);
+        hw_res_list_parsed_t hw_res;
+        hw_res_list_parsed_init(&hw_res);
+        const int ret =  hw_res_get_list_parsed(parent_sess, &hw_res, 0);
         async_hangup(parent_sess);
-        if (rc != EOK) {
-                return rc;
+        if (ret != EOK) {
+                return ret;
         }
 
-        uintptr_t mem_address = 0;
-        size_t mem_size = 0;
-        bool mem_found = false;
+        /* We want one irq and one mem range. */
+        if (hw_res.irqs.count != 1 || hw_res.mem_ranges.count != 1) {
+                hw_res_list_parsed_clean(&hw_res);
+                return EINVAL;
+        }
 
-        int irq = 0;
-        bool irq_found = false;
+        if (mem_reg_address)
+                *mem_reg_address = hw_res.mem_ranges.ranges[0].address;
+        if (mem_reg_size)
+                *mem_reg_size = hw_res.mem_ranges.ranges[0].size;
+        if (irq_no)
+                *irq_no = hw_res.irqs.irqs[0];
 
-        for (size_t 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: %p %zu.\n",
-                                    (void *) mem_address, mem_size);
-                                mem_found = true;
-                        }
-                default:
-                        break;
-                }
-        }
-        free(hw_resources.resources);
-
-        if (mem_found && irq_found) {
-                *mem_reg_address = mem_address;
-                *mem_reg_size = mem_size;
-                *irq_no = irq;
-                return EOK;
-        }
-        return ENOENT;
+        hw_res_list_parsed_clean(&hw_res);
+        return EOK;
 }
 

uspace/drv/bus/usb/ohci/root_hub.c

@@ -100 +100 @@
         .attributes = USB_TRANSFER_INTERRUPT,
         .descriptor_type = USB_DESCTYPE_ENDPOINT,
-        .endpoint_address = 1 + (1 << 7),
+        .endpoint_address = 1 | (1 << 7),
         .length = sizeof(usb_standard_endpoint_descriptor_t),
         .max_packet_size = 2,
@@ -109 +109 @@
 static void rh_init_descriptors(rh_t *instance);
 static uint16_t create_interrupt_mask(const rh_t *instance);
-static int get_status(const rh_t *instance, usb_transfer_batch_t *request);
-static int get_descriptor(const rh_t *instance, usb_transfer_batch_t *request);
-static int set_feature(const rh_t *instance, usb_transfer_batch_t *request);
-static int clear_feature(const rh_t *instance, usb_transfer_batch_t *request);
+static void get_status(const rh_t *instance, usb_transfer_batch_t *request);
+static void get_descriptor(const rh_t *instance, usb_transfer_batch_t *request);
+static void set_feature(const rh_t *instance, usb_transfer_batch_t *request);
+static void clear_feature(const rh_t *instance, usb_transfer_batch_t *request);
 static int set_feature_port(
     const rh_t *instance, uint16_t feature, uint16_t port);
 static int clear_feature_port(
     const rh_t *instance, uint16_t feature, uint16_t port);
-static int control_request(rh_t *instance, usb_transfer_batch_t *request);
+static void control_request(rh_t *instance, usb_transfer_batch_t *request);
 static inline void interrupt_request(
     usb_transfer_batch_t *request, uint16_t mask, size_t size)
 {
         assert(request);
-
-        request->transfered_size = size;
         usb_transfer_batch_finish_error(request, &mask, size, EOK);
-}
-
-#define TRANSFER_OK(bytes) \
+        usb_transfer_batch_destroy(request);
+}
+
+#define TRANSFER_END_DATA(request, data, bytes) \
 do { \
-        request->transfered_size = bytes; \
-        return EOK; \
+        usb_transfer_batch_finish_error(request, data, bytes, EOK); \
+        usb_transfer_batch_destroy(request); \
+        return; \
+} while (0)
+
+#define TRANSFER_END(request, error) \
+do { \
+        usb_transfer_batch_finish_error(request, NULL, 0, error); \
+        usb_transfer_batch_destroy(request); \
+        return; \
 } while (0)
 
@@ -212 +219 @@
         case USB_TRANSFER_CONTROL:
                 usb_log_debug("Root hub got CONTROL packet\n");
-                const int ret = control_request(instance, request);
-                usb_transfer_batch_finish_error(request, NULL, 0, ret);
+                control_request(instance, request);
                 break;
+
         case USB_TRANSFER_INTERRUPT:
                 usb_log_debug("Root hub got INTERRUPT packet\n");
@@ -221 +228 @@
                 const uint16_t mask = create_interrupt_mask(instance);
                 if (mask == 0) {
-                        usb_log_debug("No changes..\n");
+                        usb_log_debug("No changes...\n");
                         instance->unfinished_interrupt_transfer = request;
-                        fibril_mutex_unlock(&instance->guard);
-                        return;
+                } else {
+                        usb_log_debug("Processing changes...\n");
+                        interrupt_request(
+                            request, mask, instance->interrupt_mask_size);
                 }
-                usb_log_debug("Processing changes...\n");
-                interrupt_request(request, mask, instance->interrupt_mask_size);
                 fibril_mutex_unlock(&instance->guard);
                 break;
@@ -233 +240 @@
         default:
                 usb_log_error("Root hub got unsupported request.\n");
-                usb_transfer_batch_finish_error(request, NULL, 0, EINVAL);
-        }
-        usb_transfer_batch_destroy(request);
+                TRANSFER_END(request, ENOTSUP);
+        }
 }
 /*----------------------------------------------------------------------------*/
@@ -254 +260 @@
                 interrupt_request(instance->unfinished_interrupt_transfer,
                     mask, instance->interrupt_mask_size);
-                usb_transfer_batch_destroy(
-                    instance->unfinished_interrupt_transfer);
                 instance->unfinished_interrupt_transfer = NULL;
         }
@@ -384 +388 @@
  * @return error code
  */
-int get_status(const rh_t *instance, usb_transfer_batch_t *request)
+void get_status(const rh_t *instance, usb_transfer_batch_t *request)
 {
         assert(instance);
         assert(request);
+
 
         const usb_device_request_setup_packet_t *request_packet =
             (usb_device_request_setup_packet_t*)request->setup_buffer;
 
-        if (request->buffer_size < 4) {
-                usb_log_error("Buffer too small for get status request.\n");
-                return EOVERFLOW;
-        }
-
+        switch (request_packet->request_type)
+        {
+        case USB_HUB_REQ_TYPE_GET_HUB_STATUS:
         /* Hub status: just filter relevant info from rh_status reg */
-        if (request_packet->request_type == USB_HUB_REQ_TYPE_GET_HUB_STATUS) {
-                const uint32_t data = instance->registers->rh_status &
-                    (RHS_LPS_FLAG | RHS_LPSC_FLAG | RHS_OCI_FLAG | RHS_OCIC_FLAG);
-                memcpy(request->buffer, &data, sizeof(data));
-                TRANSFER_OK(sizeof(data));
-        }
+                if (request->buffer_size < 4) {
+                        usb_log_error("Buffer(%zu) too small for hub get "
+                            "status request.\n", request->buffer_size);
+                        TRANSFER_END(request, EOVERFLOW);
+                } else {
+                        const uint32_t data = instance->registers->rh_status &
+                            (RHS_LPS_FLAG | RHS_LPSC_FLAG
+                                | RHS_OCI_FLAG | RHS_OCIC_FLAG);
+                        TRANSFER_END_DATA(request, &data, sizeof(data));
+                }
 
         /* Copy appropriate rh_port_status register, OHCI designers were
          * kind enough to make those bit values match USB specification */
-        if (request_packet->request_type == USB_HUB_REQ_TYPE_GET_PORT_STATUS) {
-                const unsigned port = request_packet->index;
-                if (port < 1 || port > instance->port_count)
-                        return EINVAL;
-
-                const uint32_t data =
-                    instance->registers->rh_port_status[port - 1];
-                memcpy(request->buffer, &data, sizeof(data));
-                TRANSFER_OK(sizeof(data));
-        }
-
-        return ENOTSUP;
+        case USB_HUB_REQ_TYPE_GET_PORT_STATUS:
+                if (request->buffer_size < 4) {
+                        usb_log_error("Buffer(%zu) too small for hub get "
+                            "status request.\n", request->buffer_size);
+                        TRANSFER_END(request, EOVERFLOW);
+                } else {
+                        const unsigned port = request_packet->index;
+                        if (port < 1 || port > instance->port_count)
+                                TRANSFER_END(request, EINVAL);
+
+                        const uint32_t data =
+                            instance->registers->rh_port_status[port - 1];
+                        TRANSFER_END_DATA(request, &data, sizeof(data));
+                }
+        case SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_DEVICE):
+                if (request->buffer_size < 2) {
+                        usb_log_error("Buffer(%zu) too small for hub generic "
+                            "get status request.\n", request->buffer_size);
+                        TRANSFER_END(request, EOVERFLOW);
+                } else {
+                        static const uint16_t data =
+                            uint16_host2usb(USB_DEVICE_STATUS_SELF_POWERED);
+                        TRANSFER_END_DATA(request, &data, sizeof(data));
+                }
+
+        case SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_INTERFACE):
+                /* Hubs are allowed to have only one interface */
+                if (request_packet->index != 0)
+                        TRANSFER_END(request, EINVAL);
+                /* Fall through, as the answer will be the same: 0x0000 */
+        case SETUP_REQUEST_TO_HOST(USB_REQUEST_TYPE_STANDARD, USB_REQUEST_RECIPIENT_ENDPOINT):
+                /* Endpoint 0 (default control) and 1 (interrupt) */
+                if (request_packet->index >= 2)
+                        TRANSFER_END(request, EINVAL);
+
+                if (request->buffer_size < 2) {
+                        usb_log_error("Buffer(%zu) too small for hub generic "
+                            "get status request.\n", request->buffer_size);
+                        TRANSFER_END(request, EOVERFLOW);
+                } else {
+                        /* Endpoints are OK. (We don't halt) */
+                        static const uint16_t data = 0;
+                        TRANSFER_END_DATA(request, &data, sizeof(data));
+                }
+
+        default:
+                usb_log_error("Unsupported GET_STATUS request.\n");
+                TRANSFER_END(request, ENOTSUP);
+        }
+
 }
 /*----------------------------------------------------------------------------*/
@@ -430 +475 @@
  * @return Error code
  */
-int get_descriptor(const rh_t *instance, usb_transfer_batch_t *request)
+void get_descriptor(const rh_t *instance, usb_transfer_batch_t *request)
 {
         assert(instance);
@@ -437 +482 @@
         const usb_device_request_setup_packet_t *setup_request =
             (usb_device_request_setup_packet_t *) request->setup_buffer;
-        size_t size;
-        const void *descriptor = NULL;
         const uint16_t setup_request_value = setup_request->value_high;
-        //(setup_request->value_low << 8);
         switch (setup_request_value)
         {
         case USB_DESCTYPE_HUB:
                 usb_log_debug2("USB_DESCTYPE_HUB\n");
-                /* Hub descriptor was generated locally */
-                descriptor = instance->descriptors.hub;
-                size = instance->hub_descriptor_size;
-                break;
+                /* Hub descriptor was generated locally.
+                 * Class specific request. */
+                TRANSFER_END_DATA(request, instance->descriptors.hub,
+                    instance->hub_descriptor_size);
 
         case USB_DESCTYPE_DEVICE:
                 usb_log_debug2("USB_DESCTYPE_DEVICE\n");
-                /* Device descriptor is shared (No one should ask for it)*/
-                descriptor = &ohci_rh_device_descriptor;
-                size = sizeof(ohci_rh_device_descriptor);
-                break;
+                /* Device descriptor is shared
+                 * (No one should ask for it, as the device is already setup)
+                 * Standard USB device request. */
+                TRANSFER_END_DATA(request, &ohci_rh_device_descriptor,
+                    sizeof(ohci_rh_device_descriptor));
 
         case USB_DESCTYPE_CONFIGURATION:
                 usb_log_debug2("USB_DESCTYPE_CONFIGURATION\n");
                 /* Start with configuration and add others depending on
-                 * request size */
-                descriptor = &instance->descriptors;
-                size = instance->descriptors.configuration.total_length;
-                break;
+                 * request size. Standard USB request. */
+                TRANSFER_END_DATA(request, &instance->descriptors,
+                    instance->descriptors.configuration.total_length);
 
         case USB_DESCTYPE_INTERFACE:
                 usb_log_debug2("USB_DESCTYPE_INTERFACE\n");
                 /* Use local interface descriptor. There is one and it
-                 * might be modified */
-                descriptor = &instance->descriptors.interface;
-                size = sizeof(instance->descriptors.interface);
-                break;
+                 * might be modified. Hub driver should not ask or this
+                 * descriptor as it is not part of standard requests set. */
+                TRANSFER_END_DATA(request, &instance->descriptors.interface,
+                    sizeof(instance->descriptors.interface));
 
         case USB_DESCTYPE_ENDPOINT:
                 /* Use local endpoint descriptor. There is one
-                 * it might have max_packet_size field modified*/
+                 * it might have max_packet_size field modified. Hub driver
+                 * should not ask for this descriptor as it is not part
+                 * of standard requests set. */
                 usb_log_debug2("USB_DESCTYPE_ENDPOINT\n");
-                descriptor = &instance->descriptors.endpoint;
-                size = sizeof(instance->descriptors.endpoint);
-                break;
+                TRANSFER_END_DATA(request, &instance->descriptors.endpoint,
+                    sizeof(instance->descriptors.endpoint));
 
         default:
@@ -489 +532 @@
                     setup_request_value, setup_request->index,
                     setup_request->length);
-                return EINVAL;
-        }
-        if (request->buffer_size < size) {
-                size = request->buffer_size;
-        }
-
-        memcpy(request->buffer, descriptor, size);
-        TRANSFER_OK(size);
+                TRANSFER_END(request, EINVAL);
+        }
+
+        TRANSFER_END(request, ENOTSUP);
 }
 /*----------------------------------------------------------------------------*/
@@ -604 +643 @@
  * @return error code
  */
-int set_feature(const rh_t *instance, usb_transfer_batch_t *request)
+void set_feature(const rh_t *instance, usb_transfer_batch_t *request)
 {
         assert(instance);
@@ -615 +654 @@
         case USB_HUB_REQ_TYPE_SET_PORT_FEATURE:
                 usb_log_debug("USB_HUB_REQ_TYPE_SET_PORT_FEATURE\n");
-                return set_feature_port(instance,
+                const int ret = set_feature_port(instance,
                     setup_request->value, setup_request->index);
+                TRANSFER_END(request, ret);
 
         case USB_HUB_REQ_TYPE_SET_HUB_FEATURE:
@@ -623 +663 @@
                  * features. It makes no sense to SET either. */
                 usb_log_error("Invalid HUB set feature request.\n");
-                return ENOTSUP;
+                TRANSFER_END(request, ENOTSUP);
+        //TODO: Consider standard USB requests: REMOTE WAKEUP, ENDPOINT STALL
         default:
                 usb_log_error("Invalid set feature request type: %d\n",
                     setup_request->request_type);
-                return EINVAL;
+                TRANSFER_END(request, ENOTSUP);
         }
 }
@@ -640 +681 @@
  * @return error code
  */
-int clear_feature(const rh_t *instance, usb_transfer_batch_t *request)
+void clear_feature(const rh_t *instance, usb_transfer_batch_t *request)
 {
         assert(instance);
@@ -647 +688 @@
         const usb_device_request_setup_packet_t *setup_request =
             (usb_device_request_setup_packet_t *) request->setup_buffer;
-
-        request->transfered_size = 0;
 
         switch (setup_request->request_type)
@@ -654 +693 @@
         case USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE:
                 usb_log_debug("USB_HUB_REQ_TYPE_CLEAR_PORT_FEATURE\n");
-                return clear_feature_port(instance,
+                const int ret = clear_feature_port(instance,
                     setup_request->value, setup_request->index);
+                TRANSFER_END(request, ret);
 
         case USB_HUB_REQ_TYPE_CLEAR_HUB_FEATURE:
@@ -668 +708 @@
                 if (setup_request->value == USB_HUB_FEATURE_C_HUB_OVER_CURRENT) {
                         instance->registers->rh_status = RHS_OCIC_FLAG;
-                        TRANSFER_OK(0);
+                        TRANSFER_END(request, EOK);
                 }
+        //TODO: Consider standard USB requests: REMOTE WAKEUP, ENDPOINT STALL
         default:
                 usb_log_error("Invalid clear feature request type: %d\n",
                     setup_request->request_type);
-                return EINVAL;
+                TRANSFER_END(request, ENOTSUP);
         }
 }
@@ -695 +736 @@
  * @return error code
  */
-int control_request(rh_t *instance, usb_transfer_batch_t *request)
+void control_request(rh_t *instance, usb_transfer_batch_t *request)
 {
         assert(instance);
@@ -702 +743 @@
         if (!request->setup_buffer) {
                 usb_log_error("Root hub received empty transaction!");
-                return EINVAL;
+                TRANSFER_END(request, EBADMEM);
         }
 
         if (sizeof(usb_device_request_setup_packet_t) > request->setup_size) {
                 usb_log_error("Setup packet too small\n");
-                return EOVERFLOW;
+                TRANSFER_END(request, EOVERFLOW);
         }
 
@@ -718 +759 @@
         case USB_DEVREQ_GET_STATUS:
                 usb_log_debug("USB_DEVREQ_GET_STATUS\n");
-                return get_status(instance, request);
+                get_status(instance, request);
+                break;
 
         case USB_DEVREQ_GET_DESCRIPTOR:
                 usb_log_debug("USB_DEVREQ_GET_DESCRIPTOR\n");
-                return get_descriptor(instance, request);
+                get_descriptor(instance, request);
+                break;
 
         case USB_DEVREQ_GET_CONFIGURATION:
                 usb_log_debug("USB_DEVREQ_GET_CONFIGURATION\n");
-                if (request->buffer_size != 1)
-                        return EINVAL;
-                request->buffer[0] = 1;
-                TRANSFER_OK(1);
+                if (request->buffer_size == 0)
+                        TRANSFER_END(request, EOVERFLOW);
+                static const uint8_t config = 1;
+                TRANSFER_END_DATA(request, &config, sizeof(config));
 
         case USB_DEVREQ_CLEAR_FEATURE:
-                usb_log_debug2("Processing request without "
-                    "additional data\n");
-                return clear_feature(instance, request);
+                usb_log_debug2("USB_DEVREQ_CLEAR_FEATURE\n");
+                clear_feature(instance, request);
+                break;
 
         case USB_DEVREQ_SET_FEATURE:
-                usb_log_debug2("Processing request without "
-                    "additional data\n");
-                return set_feature(instance, request);
+                usb_log_debug2("USB_DEVREQ_SET_FEATURE\n");
+                set_feature(instance, request);
+                break;
 
         case USB_DEVREQ_SET_ADDRESS:
-                usb_log_debug("USB_DEVREQ_SET_ADDRESS\n");
+                usb_log_debug("USB_DEVREQ_SET_ADDRESS: %u\n",
+                    setup_request->value);
+                if (uint16_usb2host(setup_request->value) > 127)
+                        TRANSFER_END(request, EINVAL);
+
                 instance->address = setup_request->value;
-                TRANSFER_OK(0);
+                TRANSFER_END(request, EOK);
 
         case USB_DEVREQ_SET_CONFIGURATION:
-                usb_log_debug("USB_DEVREQ_SET_CONFIGURATION\n");
-                /* We don't need to do anything */
-                TRANSFER_OK(0);
-
-        case USB_DEVREQ_SET_DESCRIPTOR: /* Not supported by OHCI RH */
+                usb_log_debug("USB_DEVREQ_SET_CONFIGURATION: %u\n",
+                    setup_request->value);
+                /* We have only one configuration, it's number is 1 */
+                if (uint16_usb2host(setup_request->value) != 1)
+                        TRANSFER_END(request, EINVAL);
+                TRANSFER_END(request, EOK);
+
+        /* Both class specific and std is optional for hubs */
+        case USB_DEVREQ_SET_DESCRIPTOR:
+        /* Hubs have only one interface GET/SET is not supported */
+        case USB_DEVREQ_GET_INTERFACE:
+        case USB_DEVREQ_SET_INTERFACE:
         default:
+                /* Hub class GET_STATE(2) falls in here too. */
                 usb_log_error("Received unsupported request: %d.\n",
                     setup_request->request);
-                return ENOTSUP;
-        }
-}
-
+                TRANSFER_END(request, ENOTSUP);
+        }
+}
 /**
  * @}

uspace/drv/bus/usb/ohci/utils/malloc32.h

@@ -56 +56 @@
         uintptr_t result;
         int ret = as_get_physical_mapping(addr, &result);
-
+        
         if (ret != EOK)
                 return 0;
-        return (result | ((uintptr_t)addr & 0xfff));
+        
+        return result;
 }
 /*----------------------------------------------------------------------------*/

uspace/drv/bus/usb/uhci/hc.c

@@ -130 +130 @@
                         uhci_transfer_batch_t *batch =
                             uhci_transfer_batch_from_link(item);
-                        uhci_transfer_batch_call_dispose(batch);
+                        uhci_transfer_batch_finish_dispose(batch);
                 }
         }

uspace/drv/bus/usb/uhci/pci.c

@@ -26 +26 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
-
 /**
  * @addtogroup drvusbuhcihc
@@ -39 +38 @@
 #include <assert.h>
 #include <devman.h>
-#include <device/hw_res.h>
+#include <device/hw_res_parsed.h>
 
 #include <usb/debug.h>
@@ -68 +67 @@
                 return ENOMEM;
 
-        hw_resource_list_t hw_resources;
-        const int rc = hw_res_get_resource_list(parent_sess, &hw_resources);
+        hw_res_list_parsed_t hw_res;
+        hw_res_list_parsed_init(&hw_res);
+        const int ret =  hw_res_get_list_parsed(parent_sess, &hw_res, 0);
         async_hangup(parent_sess);
-        if (rc != EOK) {
-                return rc;
+        if (ret != EOK) {
+                return ret;
         }
 
-        uintptr_t io_address = 0;
-        size_t io_size = 0;
-        bool io_found = false;
+        /* We want one irq and one io range. */
+        if (hw_res.irqs.count != 1 || hw_res.io_ranges.count != 1) {
+                hw_res_list_parsed_clean(&hw_res);
+                return EINVAL;
+        }
 
-        int irq = 0;
-        bool irq_found = false;
+        if (io_reg_address)
+                *io_reg_address = hw_res.io_ranges.ranges[0].address;
+        if (io_reg_size)
+                *io_reg_size = hw_res.io_ranges.ranges[0].size;
+        if (irq_no)
+                *irq_no = hw_res.irqs.irqs[0];
 
-        for (size_t i = 0; i < hw_resources.count; i++) {
-                const 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: %" PRIx64" %zu.\n",
-                            res->res.io_range.address, res->res.io_range.size);
-                        io_found = true;
-                        break;
-                default:
-                        break;
-                }
-        }
-        free(hw_resources.resources);
-
-        if (!io_found || !irq_found)
-                return ENOENT;
-
-        *io_reg_address = io_address;
-        *io_reg_size = io_size;
-        *irq_no = irq;
-
+        hw_res_list_parsed_clean(&hw_res);
         return EOK;
 }

uspace/drv/bus/usb/uhci/transfer_list.c

@@ -184 +184 @@
                     uhci_transfer_batch_from_link(current);
                 transfer_list_remove_batch(instance, batch);
-                batch->usb_batch->error = EINTR;
-                uhci_transfer_batch_call_dispose(batch);
+                uhci_transfer_batch_abort(batch);
         }
         fibril_mutex_unlock(&instance->guard);

uspace/drv/bus/usb/uhci/uhci.c

@@ -148 +148 @@
 int device_setup_uhci(ddf_dev_t *device)
 {
-        assert(device);
-        uhci_t *instance = malloc(sizeof(uhci_t));
+        if (!device)
+                return EBADMEM;
+
+        uhci_t *instance = ddf_dev_data_alloc(device, sizeof(uhci_t));
         if (instance == NULL) {
                 usb_log_error("Failed to allocate OHCI driver.\n");
@@ -158 +160 @@
 if (ret != EOK) { \
         if (instance->hc_fun) \
-                instance->hc_fun->ops = NULL; \
                 instance->hc_fun->driver_data = NULL; \
                 ddf_fun_destroy(instance->hc_fun); \
         if (instance->rh_fun) {\
-                instance->rh_fun->ops = NULL; \
                 instance->rh_fun->driver_data = NULL; \
                 ddf_fun_destroy(instance->rh_fun); \
         } \
-        device->driver_data = NULL; \
         usb_log_error(message); \
         return ret; \
@@ -227 +226 @@
             "Failed to init uhci_hcd: %s.\n", str_error(ret));
 
-        device->driver_data = instance;
-
 #define CHECK_RET_FINI_RETURN(ret, message...) \
 if (ret != EOK) { \

uspace/drv/bus/usb/uhci/uhci_batch.c

@@ -34 +34 @@
 #include <errno.h>
 #include <str_error.h>
+#include <macros.h>
 
 #include <usb/usb.h>
@@ -45 +46 @@
 #define DEFAULT_ERROR_COUNT 3
 
+/** Safely destructs uhci_transfer_batch_t structure.
+ *
+ * @param[in] uhci_batch Instance to destroy.
+ */
 static void uhci_transfer_batch_dispose(uhci_transfer_batch_t *uhci_batch)
 {
@@ -54 +59 @@
 }
 /*----------------------------------------------------------------------------*/
-/** Safely destructs uhci_transfer_batch_t structure
- *
- * @param[in] uhci_batch Instance to destroy.
- */
-void uhci_transfer_batch_call_dispose(uhci_transfer_batch_t *uhci_batch)
+/** Finishes usb_transfer_batch and destroys the structure.
+ *
+ * @param[in] uhci_batch Instance to finish and destroy.
+ */
+void uhci_transfer_batch_finish_dispose(uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
         assert(uhci_batch->usb_batch);
         usb_transfer_batch_finish(uhci_batch->usb_batch,
-            uhci_transfer_batch_data_buffer(uhci_batch),
-            uhci_batch->usb_batch->buffer_size);
+            uhci_transfer_batch_data_buffer(uhci_batch));
         uhci_transfer_batch_dispose(uhci_batch);
 }
 /*----------------------------------------------------------------------------*/
+/** Transfer batch setup table. */
 static void (*const batch_setup[])(uhci_transfer_batch_t*, usb_direction_t);
 /*----------------------------------------------------------------------------*/
 /** Allocate memory and initialize internal data structure.
  *
- * @param[in] fun DDF function to pass to callback.
- * @param[in] ep Communication target
- * @param[in] buffer Data source/destination.
- * @param[in] buffer_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 transfer completion
- * @param[in] func_out function to call on outbound transfer completion
- * @param[in] arg additional parameter to func_in or func_out
+ * @param[in] usb_batch Pointer to generic USB batch structure.
  * @return Valid pointer if all structures were successfully created,
  * NULL otherwise.
@@ -156 +153 @@
  * is reached.
  */
-bool uhci_transfer_batch_is_complete(uhci_transfer_batch_t *uhci_batch)
+bool uhci_transfer_batch_is_complete(const uhci_transfer_batch_t *uhci_batch)
 {
         assert(uhci_batch);
@@ -200 +197 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Direction to pid conversion table */
 static const usb_packet_id direction_pids[] = {
         [USB_DIRECTION_IN] = USB_PID_IN,
@@ -237 +235 @@
 
         while (remain_size > 0) {
-                const size_t packet_size =
-                    (remain_size < mps) ? remain_size : mps;
+                const size_t packet_size = min(remain_size, mps);
 
                 const td_t *next_td = (td + 1 < uhci_batch->td_count)
@@ -309 +306 @@
 
         while (remain_size > 0) {
-                const size_t packet_size =
-                    (remain_size < mps) ? remain_size : mps;
+                const size_t packet_size = min(remain_size, mps);
 
                 td_init(

uspace/drv/bus/usb/uhci/uhci_batch.h

@@ -61 +61 @@
 
 uhci_transfer_batch_t * uhci_transfer_batch_get(usb_transfer_batch_t *batch);
-void uhci_transfer_batch_call_dispose(uhci_transfer_batch_t *uhci_batch);
-bool uhci_transfer_batch_is_complete(uhci_transfer_batch_t *uhci_batch);
+void uhci_transfer_batch_finish_dispose(uhci_transfer_batch_t *uhci_batch);
+bool uhci_transfer_batch_is_complete(const uhci_transfer_batch_t *uhci_batch);
 
+/** Get offset to setup buffer accessible to the HC hw.
+ * @param uhci_batch UHCI batch structure.
+ * @return Pointer to the setup buffer.
+ */
 static inline void * uhci_transfer_batch_setup_buffer(
     const uhci_transfer_batch_t *uhci_batch)
@@ -73 +77 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Get offset to data buffer accessible to the HC hw.
+ * @param uhci_batch UHCI batch structure.
+ * @return Pointer to the data buffer.
+ */
 static inline void * uhci_transfer_batch_data_buffer(
     const uhci_transfer_batch_t *uhci_batch)
@@ -82 +90 @@
 }
 /*----------------------------------------------------------------------------*/
+/** Aborts the batch.
+ * Sets error to EINTR and size off transferd data to 0, before finishing the
+ * batch.
+ * @param uhci_batch Batch to abort.
+ */
+static inline void uhci_transfer_batch_abort(uhci_transfer_batch_t *uhci_batch)
+{
+        assert(uhci_batch);
+        assert(uhci_batch->usb_batch);
+        uhci_batch->usb_batch->error = EINTR;
+        uhci_batch->usb_batch->transfered_size = 0;
+        uhci_transfer_batch_finish_dispose(uhci_batch);
+}
+/*----------------------------------------------------------------------------*/
+/** Linked list conversion wrapper.
+ * @param l Linked list link.
+ * @return Pointer to the uhci batch structure.
+ */
 static inline uhci_transfer_batch_t *uhci_transfer_batch_from_link(link_t *l)
 {

uspace/drv/bus/usb/uhci/utils/malloc32.h

@@ -54 +54 @@
         if (addr == NULL)
                 return 0;
-
+        
         uintptr_t result;
         const int ret = as_get_physical_mapping(addr, &result);
         if (ret != EOK)
                 return 0;
-        return (result | ((uintptr_t)addr & 0xfff));
+        
+        return result;
 }
 /*----------------------------------------------------------------------------*/
@@ -97 +98 @@
 static inline void * get_page(void)
 {
-        void *free_address = as_get_mappable_page(UHCI_REQUIRED_PAGE_SIZE);
-        if (free_address == 0)
+        void *address = as_area_create((void *) -1, UHCI_REQUIRED_PAGE_SIZE,
+            AS_AREA_READ | AS_AREA_WRITE);
+        if (address == (void *) -1)
                 return NULL;
-        void *address = as_area_create(free_address, UHCI_REQUIRED_PAGE_SIZE,
-                  AS_AREA_READ | AS_AREA_WRITE);
-        if (address != free_address)
-                return NULL;
+        
         return address;
 }

uspace/drv/bus/usb/uhcirh/main.c

@@ -36 +36 @@
 #include <ddf/driver.h>
 #include <devman.h>
-#include <device/hw_res.h>
+#include <device/hw_res_parsed.h>
 #include <errno.h>
 #include <str_error.h>
@@ -136 +136 @@
 {
         assert(dev);
-        
+
         async_sess_t *parent_sess =
             devman_parent_device_connect(EXCHANGE_SERIALIZE, dev->handle,
@@ -142 +142 @@
         if (!parent_sess)
                 return ENOMEM;
-        
-        hw_resource_list_t hw_resources;
-        const int ret = hw_res_get_resource_list(parent_sess, &hw_resources);
+
+        hw_res_list_parsed_t hw_res;
+        hw_res_list_parsed_init(&hw_res);
+        const int ret =  hw_res_get_list_parsed(parent_sess, &hw_res, 0);
+        async_hangup(parent_sess);
         if (ret != EOK) {
-                async_hangup(parent_sess);
                 return ret;
         }
-        
-        uintptr_t io_address = 0;
-        size_t io_size = 0;
-        bool io_found = false;
-        
-        size_t i = 0;
-        for (; i < hw_resources.count; i++) {
-                hw_resource_t *res = &hw_resources.resources[i];
-                if (res->type == IO_RANGE) {
-                        io_address = res->res.io_range.address;
-                        io_size = res->res.io_range.size;
-                        io_found = true;
-                }
-        
+
+        if (hw_res.io_ranges.count != 1) {
+                hw_res_list_parsed_clean(&hw_res);
+                return EINVAL;
         }
-        async_hangup(parent_sess);
-        
-        if (!io_found)
-                return ENOENT;
-        
+
         if (io_reg_address != NULL)
-                *io_reg_address = io_address;
-        
+                *io_reg_address = hw_res.io_ranges.ranges[0].address;
+
         if (io_reg_size != NULL)
-                *io_reg_size = io_size;
-        
+                *io_reg_size = hw_res.io_ranges.ranges[0].size;
+
+        hw_res_list_parsed_clean(&hw_res);
         return EOK;
 }

uspace/drv/bus/usb/uhcirh/port.c

@@ -260 +260 @@
 {
         assert(port);
-        assert(usb_hc_connection_is_opened(&port->hc_connection));
 
         usb_log_debug("%s: Detected new device.\n", port->id_string);
@@ -314 +313 @@
 
         /* Driver stopped, free used address */
-        ret = usb_hc_unregister_device(&port->hc_connection,
-            port->attached_device.address);
+        ret = usb_hub_unregister_device(&port->hc_connection,
+            &port->attached_device);
         if (ret != EOK) {
                 usb_log_error("%s: Failed to unregister address of removed "

uspace/drv/bus/usb/usbhub/port.c

@@ -288 +288 @@
         port->attached_device.fun = NULL;
 
-        ret = usb_hc_connection_open(&hub->connection);
-        if (ret == EOK) {
-                ret = usb_hc_unregister_device(&hub->connection,
-                    port->attached_device.address);
-                if (ret != EOK) {
-                        usb_log_warning("Failed to unregister address of the "
-                            "removed device: %s.\n", str_error(ret));
-                }
-                ret = usb_hc_connection_close(&hub->connection);
-                if (ret != EOK) {
-                        usb_log_warning("Failed to close hc connection %s.\n",
-                            str_error(ret));
-                }
-
-        } else {
-                usb_log_warning("Failed to open hc connection %s.\n",
-                    str_error(ret));
+        ret = usb_hub_unregister_device(&hub->usb_device->hc_conn,
+            &port->attached_device);
+        if (ret != EOK) {
+                usb_log_warning("Failed to unregister address of the "
+                    "removed device: %s.\n", str_error(ret));
         }
 
@@ -438 +426 @@
 
         const int rc = usb_hc_new_device_wrapper(data->hub->usb_device->ddf_dev,
-            &data->hub->connection, data->speed, enable_port_callback,
+            &data->hub->usb_device->hc_conn, data->speed, enable_port_callback,
             data->port, &new_address, NULL, NULL, &child_fun);
 

uspace/drv/bus/usb/usbhub/usbhub.c

@@ -99 +99 @@
         fibril_condvar_initialize(&hub_dev->pending_ops_cv);
 
-        /* Create hc connection */
-        usb_log_debug("Initializing USB wire abstraction.\n");
-        int opResult = usb_hc_connection_initialize_from_device(
-            &hub_dev->connection, hub_dev->usb_device->ddf_dev);
-        if (opResult != EOK) {
-                usb_log_error("Could not initialize connection to device: %s\n",
+
+        int opResult = usb_pipe_start_long_transfer(&usb_dev->ctrl_pipe);
+        if (opResult != EOK) {
+                usb_log_error("Failed to start long ctrl pipe transfer: %s\n",
                     str_error(opResult));
                 return opResult;
@@ -112 +110 @@
         opResult = usb_set_first_configuration(usb_dev);
         if (opResult != EOK) {
+                usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
                 usb_log_error("Could not set hub configuration: %s\n",
                     str_error(opResult));
@@ -120 +119 @@
         opResult = usb_hub_process_hub_specific_info(hub_dev);
         if (opResult != EOK) {
+                usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
                 usb_log_error("Could process hub specific info, %s\n",
                     str_error(opResult));
@@ -130 +130 @@
             fun_exposed, HUB_FNC_NAME);
         if (hub_dev->hub_fun == NULL) {
+                usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
                 usb_log_error("Failed to create hub function.\n");
                 return ENOMEM;
@@ -137 +138 @@
         opResult = ddf_fun_bind(hub_dev->hub_fun);
         if (opResult != EOK) {
+                usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
                 usb_log_error("Failed to bind hub function: %s.\n",
                    str_error(opResult));
@@ -148 +150 @@
             usb_hub_polling_terminated_callback, hub_dev);
         if (opResult != EOK) {
+                usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
                 /* Function is already bound */
                 ddf_fun_unbind(hub_dev->hub_fun);
@@ -159 +162 @@
             hub_dev->usb_device->ddf_dev->name, hub_dev->port_count);
 
+        usb_pipe_end_long_transfer(&usb_dev->ctrl_pipe);
         return EOK;
 }

uspace/drv/bus/usb/usbhub/usbhub.h

@@ -57 +57 @@
         /** Port structures, one for each port */
         usb_hub_port_t *ports;
-        /** Connection to hcd */
-        usb_hc_connection_t connection;
         /** Generic usb device data*/
         usb_device_t *usb_device;

uspace/drv/bus/usb/usbmast/main.c

@@ -300 +300 @@
                 return;
         }
-
-        comm_buf = as_get_mappable_page(comm_size);
-        if (comm_buf == NULL) {
+        
+        (void) async_share_out_finalize(callid, &comm_buf);
+        if (comm_buf == (void *) -1) {
                 async_answer_0(callid, EHANGUP);
                 return;
         }
-
-        (void) async_share_out_finalize(callid, comm_buf);
-
+        
         mfun = (usbmast_fun_t *) ((ddf_fun_t *)arg)->driver_data;
 

uspace/drv/bus/usb/usbmid/main.c

@@ -53 +53 @@
         usb_log_info("Taking care of new MID `%s'.\n", dev->ddf_dev->name);
 
-        usb_pipe_start_long_transfer(&dev->ctrl_pipe);
-
-        bool accept = usbmid_explore_device(dev);
-
-        usb_pipe_end_long_transfer(&dev->ctrl_pipe);
+        const bool accept = usbmid_explore_device(dev);
 
         if (!accept) {

uspace/drv/bus/usb/vhc/hub.c

@@ -107 +107 @@
 
         usb_hc_connection_t hc_conn;
-        rc = usb_hc_connection_initialize(&hc_conn, hc_dev->handle);
-        assert(rc == EOK);
+        usb_hc_connection_initialize(&hc_conn, hc_dev->handle);
 
         rc = usb_hc_connection_open(&hc_conn);