Changeset 99c2c69e in mainline for uspace/drv/bus

Timestamp:

2013-09-13T00:36:30Z (13 years ago)

Author:

Jan Vesely <jano.vesely@…>

Branches:

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

Children:

67fbd5e

Parents:

7f84430 (diff), 11d41be5 (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/i8237.c (modified) (1 diff)
• isa/isa.c (modified) (12 diffs)
• pci/pciintel/pci.c (modified) (16 diffs)
• pci/pciintel/pci.h (modified) (2 diffs)
• usb/ehci/main.c (modified) (2 diffs)
• usb/ehci/res.c (modified) (4 diffs)
• usb/ehci/res.h (modified) (1 diff)
• usb/ohci/hc.c (modified) (6 diffs)
• usb/ohci/hc.h (modified) (1 diff)
• usb/ohci/ohci.c (modified) (3 diffs)
• usb/ohci/res.c (modified) (3 diffs)
• usb/ohci/res.h (modified) (1 diff)
• usb/uhci/hc.c (modified) (9 diffs)
• usb/uhci/hc.h (modified) (3 diffs)
• usb/uhci/res.c (modified) (2 diffs)
• usb/uhci/res.h (modified) (1 diff)
• usb/uhci/uhci.c (modified) (4 diffs)
• usb/uhci/utils/malloc32.h (modified) (2 diffs)
• usb/uhcirh/main.c (modified) (6 diffs)
• usb/uhcirh/root_hub.c (modified) (2 diffs)
• usb/uhcirh/root_hub.h (modified) (2 diffs)
• usb/usbmid/explore.c (modified) (2 diffs)
• usb/usbmid/usbmid.c (modified) (1 diff)
• usb/vhc/transfer.c (modified) (1 diff)

uspace/drv/bus/isa/i8237.c

@@ -279 +279 @@
  *
  * @return Error code.
+ *
  */
 static inline int dma_controller_init(dma_controller_t *controller)

uspace/drv/bus/isa/isa.c

@@ -65 +65 @@
 #include <ddf/log.h>
 #include <ops/hw_res.h>
+#include <ops/pio_window.h>
 
 #include <device/hw_res.h>
+#include <device/pio_window.h>
 
 #include "i8237.h"
@@ -79 +81 @@
         ddf_dev_t *dev;
         ddf_fun_t *fctl;
+        pio_window_t pio_win;
         list_t functions;
 } isa_bus_t;
@@ -102 +105 @@
 }
 
-static hw_resource_list_t *isa_get_fun_resources(ddf_fun_t *fnode)
-{
-        isa_fun_t *isa = isa_fun(fnode);
-        assert(isa);
-
-        return &isa->hw_resources;
+static hw_resource_list_t *isa_fun_get_resources(ddf_fun_t *fnode)
+{
+        isa_fun_t *fun = isa_fun(fnode);
+        assert(fun);
+
+        return &fun->hw_resources;
 }
 
@@ -114 +117 @@
         /* This is an old ugly way, copied from pci driver */
         assert(fnode);
-        isa_fun_t *isa = isa_fun(fnode);
-        assert(isa);
+        isa_fun_t *fun = isa_fun(fnode);
+        assert(fun);
 
         sysarg_t apic;
@@ -131 +134 @@
                 return false;
 
-        const hw_resource_list_t *res = &isa->hw_resources;
+        const hw_resource_list_t *res = &fun->hw_resources;
         assert(res);
         for (size_t i = 0; i < res->count; ++i) {
@@ -157 +160 @@
 {
         assert(fnode);
-        isa_fun_t *isa = isa_fun(fnode);
-        assert(isa);
-        const hw_resource_list_t *res = &isa->hw_resources;
+        isa_fun_t *fun = isa_fun(fnode);
+        assert(fun);
+        const hw_resource_list_t *res = &fun->hw_resources;
         assert(res);
 
@@ -180 +183 @@
         assert(size);
         assert(fnode);
-        isa_fun_t *isa = isa_fun(fnode);
-        assert(isa);
-        const hw_resource_list_t *res = &isa->hw_resources;
+        isa_fun_t *fun = isa_fun(fnode);
+        assert(fun);
+        const hw_resource_list_t *res = &fun->hw_resources;
         assert(res);
 
@@ -199 +202 @@
 
 static hw_res_ops_t isa_fun_hw_res_ops = {
-        .get_resource_list = isa_get_fun_resources,
+        .get_resource_list = isa_fun_get_resources,
         .enable_interrupt = isa_fun_enable_interrupt,
         .dma_channel_setup = isa_fun_setup_dma,
@@ -205 +208 @@
 };
 
+static pio_window_t *isa_fun_get_pio_window(ddf_fun_t *fnode)
+{
+        ddf_dev_t *dev = ddf_fun_get_dev(fnode);
+        isa_bus_t *isa = isa_bus(dev);
+        assert(isa);
+
+        return &isa->pio_win;
+}
+
+static pio_window_ops_t isa_fun_pio_window_ops = {
+        .get_pio_window = isa_fun_get_pio_window
+};
+
 static ddf_dev_ops_t isa_fun_ops= {
         .interfaces[HW_RES_DEV_IFACE] = &isa_fun_hw_res_ops,
+        .interfaces[PIO_WINDOW_DEV_IFACE] = &isa_fun_pio_window_ops,
 };
 
@@ -405 +422 @@
         hw_resource_t *resources = fun->hw_resources.resources;
 
+        isa_bus_t *isa = isa_bus(ddf_fun_get_dev(fun->fnode));
+
         if (count < ISA_MAX_HW_RES) {
                 resources[count].type = IO_RANGE;
                 resources[count].res.io_range.address = addr;
+                resources[count].res.io_range.address += isa->pio_win.io.base;
                 resources[count].res.io_range.size = len;
+                resources[count].res.io_range.relative = false;
                 resources[count].res.io_range.endianness = LITTLE_ENDIAN;
 
@@ -604 +625 @@
 static int isa_dev_add(ddf_dev_t *dev)
 {
+        async_sess_t *sess;
+        int rc;
+
         ddf_msg(LVL_DEBUG, "isa_dev_add, device handle = %d",
             (int) ddf_dev_get_handle(dev));
@@ -614 +638 @@
         isa->dev = dev;
         list_initialize(&isa->functions);
+
+        sess = ddf_dev_parent_sess_create(dev, EXCHANGE_SERIALIZE);
+        if (sess == NULL) {
+                ddf_msg(LVL_ERROR, "isa_dev_add failed to connect to the "
+                    "parent driver.");
+                return ENOENT;
+        }
+
+        rc = pio_window_get(sess, &isa->pio_win);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "isa_dev_add failed to get PIO window "
+                    "for the device.");
+                return rc;
+        }       
 
         /* Make the bus device more visible. Does not do anything. */

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

@@ -57 +57 @@
 #include <ops/hw_res.h>
 #include <device/hw_res.h>
+#include <ops/pio_window.h>
+#include <device/pio_window.h>
 #include <ddi.h>
 #include <pci_dev_iface.h>
@@ -141 +143 @@
 }
 
+static pio_window_t *pciintel_get_pio_window(ddf_fun_t *fnode)
+{
+        pci_fun_t *fun = pci_fun(fnode);
+        
+        if (fun == NULL)
+                return NULL;
+        return &fun->pio_window;
+}
+
+
 static int pci_config_space_write_32(ddf_fun_t *fun, uint32_t address,
     uint32_t data)
@@ -198 +210 @@
         .get_resource_list = &pciintel_get_resources,
         .enable_interrupt = &pciintel_enable_interrupt,
+};
+
+static pio_window_ops_t pciintel_pio_window_ops = {
+        .get_pio_window = &pciintel_get_pio_window
 };
 
@@ -211 +227 @@
 static ddf_dev_ops_t pci_fun_ops = {
         .interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops,
+        .interfaces[PIO_WINDOW_DEV_IFACE] = &pciintel_pio_window_ops,
         .interfaces[PCI_DEV_IFACE] = &pci_dev_ops
 };
@@ -233 +250 @@
 static void pci_conf_read(pci_fun_t *fun, int reg, uint8_t *buf, size_t len)
 {
+        const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
         pci_bus_t *bus = pci_bus_from_fun(fun);
+        uint32_t val;
         
         fibril_mutex_lock(&bus->conf_mutex);
-        
-        const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
-        void *addr = bus->conf_data_port + (reg & 3);
-        
-        pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
-        
+
+        pio_write_32(bus->conf_addr_reg, host2uint32_t_le(conf_addr));
+
+        /*
+         * Always read full 32-bits from the PCI conf_data_port register and
+         * get the desired portion of it afterwards. Some architectures do not
+         * support shorter PIO reads offset from this register.
+         */
+        val = uint32_t_le2host(pio_read_32(bus->conf_data_reg));
+
         switch (len) {
         case 1:
-                /* No endianness change for 1 byte */
-                buf[0] = pio_read_8(addr);
+                *buf = (uint8_t) (val >> ((reg & 3) * 8));
                 break;
         case 2:
-                ((uint16_t *) buf)[0] = uint16_t_le2host(pio_read_16(addr));
+                *((uint16_t *) buf) = (uint16_t) (val >> ((reg & 3)) * 8);
                 break;
         case 4:
-                ((uint32_t *) buf)[0] = uint32_t_le2host(pio_read_32(addr));
+                *((uint32_t *) buf) = (uint32_t) val;
                 break;
         }
@@ -260 +282 @@
 static void pci_conf_write(pci_fun_t *fun, int reg, uint8_t *buf, size_t len)
 {
+        const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
         pci_bus_t *bus = pci_bus_from_fun(fun);
+        uint32_t val;
         
         fibril_mutex_lock(&bus->conf_mutex);
-        
-        const uint32_t conf_addr = CONF_ADDR(fun->bus, fun->dev, fun->fn, reg);
-        void *addr = bus->conf_data_port + (reg & 3);
-        
-        pio_write_32(bus->conf_addr_port, host2uint32_t_le(conf_addr));
+
+        /*
+         * Prepare to write full 32-bits to the PCI conf_data_port register.
+         * Some architectures do not support shorter PIO writes offset from this
+         * register.
+         */
+
+        if (len < 4) {
+                /*
+                 * We have fewer than full 32-bits, so we need to read the
+                 * missing bits first.
+                 */
+                pio_write_32(bus->conf_addr_reg, host2uint32_t_le(conf_addr));
+                val = uint32_t_le2host(pio_read_32(bus->conf_data_reg));
+        }
         
         switch (len) {
         case 1:
-                /* No endianness change for 1 byte */
-                pio_write_8(addr, buf[0]);
+                val &= ~(0xffU << ((reg & 3) * 8));
+                val |= *buf << ((reg & 3) * 8);
                 break;
         case 2:
-                pio_write_16(addr, host2uint16_t_le(((uint16_t *) buf)[0]));
+                val &= ~(0xffffU << ((reg & 3) * 8));
+                val |= *((uint16_t *) buf) << ((reg & 3) * 8);
                 break;
         case 4:
-                pio_write_32(addr, host2uint32_t_le(((uint32_t *) buf)[0]));
+                val = *((uint32_t *) buf);
                 break;
         }
+
+        pio_write_32(bus->conf_addr_reg, host2uint32_t_le(conf_addr));
+        pio_write_32(bus->conf_data_reg, host2uint32_t_le(val));
         
         fibril_mutex_unlock(&bus->conf_mutex);
@@ -411 +449 @@
                 hw_resources[count].res.io_range.address = range_addr;
                 hw_resources[count].res.io_range.size = range_size;
+                hw_resources[count].res.io_range.relative = true;
                 hw_resources[count].res.io_range.endianness = LITTLE_ENDIAN;
         } else {
@@ -416 +455 @@
                 hw_resources[count].res.mem_range.address = range_addr;
                 hw_resources[count].res.mem_range.size = range_size;
+                hw_resources[count].res.mem_range.relative = false;
                 hw_resources[count].res.mem_range.endianness = LITTLE_ENDIAN;
         }
@@ -433 +473 @@
 {
         /* Value of the BAR */
-        uint32_t val, mask;
+        uint32_t val;
+        uint32_t bar;
+        uint32_t mask;
+
         /* IO space address */
         bool io;
@@ -471 +514 @@
         /* Get the address mask. */
         pci_conf_write_32(fun, addr, 0xffffffff);
-        mask &= pci_conf_read_32(fun, addr);
-        
+        bar = pci_conf_read_32(fun, addr);
+
+        /*
+         * Unimplemented BARs read back as all 0's.
+         */
+        if (!bar)
+                return addr + (addrw64 ? 8 : 4);
+
+        mask &= bar;    
+
         /* Restore the original value. */
         pci_conf_write_32(fun, addr, val);
@@ -520 +571 @@
 {
         uint8_t irq = pci_conf_read_8(fun, PCI_BRIDGE_INT_LINE);
-        if (irq != 0xff)
+        uint8_t pin = pci_conf_read_8(fun, PCI_BRIDGE_INT_PIN);
+
+        if (pin != 0 && irq != 0xff)
                 pci_add_interrupt(fun, irq);
 }
@@ -583 +636 @@
                         pci_read_bars(fun);
                         pci_read_interrupt(fun);
+
+                        /* Propagate the PIO window to the function. */
+                        fun->pio_window = bus->pio_win;
                         
                         ddf_fun_set_ops(fun->fnode, &pci_fun_ops);
@@ -613 +669 @@
 static int pci_dev_add(ddf_dev_t *dnode)
 {
+        hw_resource_list_t hw_resources;
         pci_bus_t *bus = NULL;
         ddf_fun_t *ctl = NULL;
@@ -638 +695 @@
                 goto fail;
         }
-        
-        hw_resource_list_t hw_resources;
+
+        rc = pio_window_get(sess, &bus->pio_win);
+        if (rc != EOK) {
+                ddf_msg(LVL_ERROR, "pci_dev_add failed to get PIO window "
+                    "for the device.");
+                goto fail;
+        }
         
         rc = hw_res_get_resource_list(sess, &hw_resources);
@@ -662 +724 @@
             hw_resources.resources[1].res.io_range.address);
         
-        bus->conf_io_addr =
-            (uint32_t) hw_resources.resources[0].res.io_range.address;
-        bus->conf_io_data =
-            (uint32_t) hw_resources.resources[1].res.io_range.address;
-        
-        if (pio_enable((void *)(uintptr_t)bus->conf_io_addr, 4,
-            &bus->conf_addr_port)) {
+        if (pio_enable_resource(&bus->pio_win, &hw_resources.resources[0],
+            (void **) &bus->conf_addr_reg)) {
                 ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
                 rc = EADDRNOTAVAIL;
                 goto fail;
         }
-        if (pio_enable((void *)(uintptr_t)bus->conf_io_data, 4,
-            &bus->conf_data_port)) {
+        if (pio_enable_resource(&bus->pio_win, &hw_resources.resources[1],
+            (void **) &bus->conf_data_reg)) {
                 ddf_msg(LVL_ERROR, "Failed to enable configuration ports.");
                 rc = EADDRNOTAVAIL;
@@ -729 +786 @@
 {
         ddf_log_init(NAME);
-        pci_fun_ops.interfaces[HW_RES_DEV_IFACE] = &pciintel_hw_res_ops;
-        pci_fun_ops.interfaces[PCI_DEV_IFACE] = &pci_dev_ops;
 }
 

uspace/drv/bus/pci/pciintel/pci.h

@@ -40 +40 @@
 #include "pci_regs.h"
 
-#define PCI_MAX_HW_RES 8
+#define PCI_MAX_HW_RES 10 
 
 typedef struct pciintel_bus {
         /** DDF device node */
         ddf_dev_t *dnode;
-        uint32_t conf_io_addr;
-        uint32_t conf_io_data;
-        void *conf_data_port;
-        void *conf_addr_port;
+        ioport32_t *conf_addr_reg;
+        ioport32_t *conf_data_reg;
+        pio_window_t pio_win;
         fibril_mutex_t conf_mutex;
 } pci_bus_t;
@@ -68 +67 @@
         hw_resource_list_t hw_resources;
         hw_resource_t resources[PCI_MAX_HW_RES];
+        pio_window_t pio_window;
 } pci_fun_t;
 

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

@@ -77 +77 @@
         assert(device);
 
-        uintptr_t reg_base = 0;
-        size_t reg_size = 0;
+        addr_range_t reg_range;
         int irq = 0;
 
-        int rc = get_my_registers(device, &reg_base, &reg_size, &irq);
+        int rc = get_my_registers(device, &reg_range, &irq);
         if (rc != EOK) {
                 usb_log_error("Failed to get memory addresses for %" PRIun
@@ -88 +87 @@
         }
 
-        usb_log_info("Memory mapped regs at 0x%" PRIxn " (size %zu), IRQ %d.\n",
-            reg_base, reg_size, irq);
+        usb_log_info("Memory mapped regs at %p (size %zu), IRQ %d.\n",
+            RNGABSPTR(reg_range), RNGSZ(reg_range), irq);
 
-        rc = disable_legacy(device, reg_base, reg_size);
+        rc = disable_legacy(device, &reg_range);
         if (rc != EOK) {
                 usb_log_error("Failed to disable legacy USB: %s.\n",

uspace/drv/bus/usb/ehci/res.c

@@ -71 +71 @@
  *
  * @param[in] dev Device asking for the addresses.
- * @param[out] mem_reg_address Base address of the memory range.
- * @param[out] mem_reg_size Size of the memory range.
+ * @param[out] mem_regs_p Pointer to the register range.
  * @param[out] irq_no IRQ assigned to the device.
  * @return Error code.
  */
 int get_my_registers(ddf_dev_t *dev,
-    uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no)
+    addr_range_t *mem_regs_p, int *irq_no)
 {
         assert(dev);
@@ -99 +98 @@
         }
 
-        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 (mem_regs_p)
+                *mem_regs_p = hw_res.mem_ranges.ranges[0];
         if (irq_no)
                 *irq_no = hw_res.irqs.irqs[0];
@@ -267 +264 @@
 }
 
-int disable_legacy(ddf_dev_t *device, uintptr_t reg_base, size_t reg_size)
+int disable_legacy(ddf_dev_t *device, addr_range_t *reg_range)
 {
         assert(device);
@@ -274 +271 @@
         /* Map EHCI registers */
         void *regs = NULL;
-        int rc = pio_enable((void*)reg_base, reg_size, &regs);
+        int rc = pio_enable_range(reg_range, &regs);
         if (rc != EOK) {
                 usb_log_error("Failed to map registers %p: %s.\n",
-                    (void *) reg_base, str_error(rc));
+                    RNGABSPTR(*reg_range), str_error(rc));
                 return rc;
         }

uspace/drv/bus/usb/ehci/res.h

@@ -37 +37 @@
 
 #include <ddf/driver.h>
+#include <device/hw_res_parsed.h>
 
-int get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
+int get_my_registers(ddf_dev_t *, addr_range_t *, int *);
 int enable_interrupts(ddf_dev_t *);
-int disable_legacy(ddf_dev_t *, uintptr_t, size_t);
+int disable_legacy(ddf_dev_t *, addr_range_t *);
 
 #endif

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

@@ -106 +106 @@
  * @param[out] cmds Commands buffer.
  * @param[in] cmds_size Size of the commands buffer (bytes).
- * @param[in] regs Physical address of device's registers.
- * @param[in] reg_size Size of the register area (bytes).
+ * @param[in] regs Device's register range.
  *
  * @return Error code.
@@ -113 +112 @@
 int
 hc_get_irq_code(irq_pio_range_t ranges[], size_t ranges_size, irq_cmd_t cmds[],
-    size_t cmds_size, uintptr_t regs, size_t reg_size)
+    size_t cmds_size, addr_range_t *regs)
 {
         if ((ranges_size < sizeof(ohci_pio_ranges)) ||
             (cmds_size < sizeof(ohci_irq_commands)) ||
-            (reg_size < sizeof(ohci_regs_t)))
+            (RNGSZ(*regs) < sizeof(ohci_regs_t)))
                 return EOVERFLOW;
 
         memcpy(ranges, ohci_pio_ranges, sizeof(ohci_pio_ranges));
-        ranges[0].base = regs;
+        ranges[0].base = RNGABS(*regs);
 
         memcpy(cmds, ohci_irq_commands, sizeof(ohci_irq_commands));
-        ohci_regs_t *registers = (ohci_regs_t *) regs;
+        ohci_regs_t *registers = (ohci_regs_t *) RNGABSPTR(*regs);
         cmds[0].addr = (void *) &registers->interrupt_status;
         cmds[3].addr = (void *) &registers->interrupt_status;
@@ -135 +134 @@
  *
  * @param[in] device Host controller DDF device
- * @param[in] reg_base Register range base
- * @param[in] reg_size Register range size
+ * @param[in] regs Register range
  * @param[in] irq Interrupt number
  * @paran[in] handler Interrupt handler
@@ -142 +140 @@
  * @return EOK on success or negative error code
  */
-int hc_register_irq_handler(ddf_dev_t *device, uintptr_t reg_base, size_t reg_size,
-    int irq, interrupt_handler_t handler)
+int hc_register_irq_handler(ddf_dev_t *device, addr_range_t *regs, int irq,
+    interrupt_handler_t handler)
 {
         int rc;
@@ -158 +156 @@
 
         rc = hc_get_irq_code(irq_ranges, sizeof(irq_ranges), irq_cmds,
-            sizeof(irq_cmds), reg_base, reg_size);
+            sizeof(irq_cmds), regs);
         if (rc != EOK) {
                 usb_log_error("Failed to generate IRQ code: %s.\n",
@@ -259 +257 @@
  *
  * @param[in] instance Memory place for the structure.
- * @param[in] regs Address of the memory mapped I/O registers.
- * @param[in] reg_size Size of the memory mapped area.
+ * @param[in] regs Device's I/O registers range.
  * @param[in] interrupts True if w interrupts should be used
  * @return Error code
  */
-int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts)
-{
-        assert(instance);
-
-        int rc =
-            pio_enable((void*)regs, reg_size, (void**)&instance->registers);
+int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts)
+{
+        assert(instance);
+
+        int rc = pio_enable_range(regs, (void **) &instance->registers);
         if (rc != EOK) {
                 usb_log_error("Failed to gain access to device registers: %s.\n",

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

@@ -75 +75 @@
 } hc_t;
 
-int hc_get_irq_code(irq_pio_range_t [], size_t, irq_cmd_t [], size_t, uintptr_t,
-    size_t);
-int hc_register_irq_handler(ddf_dev_t *, uintptr_t, size_t, int, interrupt_handler_t);
+int hc_get_irq_code(irq_pio_range_t [], size_t, irq_cmd_t [], size_t,
+    addr_range_t *);
+int hc_register_irq_handler(ddf_dev_t *, addr_range_t *, int,
+    interrupt_handler_t);
 int hc_register_hub(hc_t *instance, ddf_fun_t *hub_fun);
-int hc_init(hc_t *instance, uintptr_t regs, size_t reg_size, bool interrupts);
+int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts);
 
 /** Safely dispose host controller internal structures

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

@@ -177 +177 @@
         ddf_fun_set_ops(instance->rh_fun, &rh_ops);
 
-        uintptr_t reg_base = 0;
-        size_t reg_size = 0;
+        addr_range_t regs;
         int irq = 0;
 
-        rc = get_my_registers(device, &reg_base, &reg_size, &irq);
+        rc = get_my_registers(device, &regs, &irq);
         if (rc != EOK) {
                 usb_log_error("Failed to get register memory addresses "
@@ -190 +189 @@
 
         usb_log_debug("Memory mapped regs at %p (size %zu), IRQ %d.\n",
-            (void *) reg_base, reg_size, irq);
-
-        rc = hc_register_irq_handler(device, reg_base, reg_size, irq, irq_handler);
+            RNGABSPTR(regs), RNGSZ(regs), irq);
+
+        rc = hc_register_irq_handler(device, &regs, irq, irq_handler);
         if (rc != EOK) {
                 usb_log_error("Failed to register interrupt handler: %s.\n",
@@ -215 +214 @@
         }
 
-        rc = hc_init(&instance->hc, reg_base, reg_size, interrupts);
+        rc = hc_init(&instance->hc, &regs, interrupts);
         if (rc != EOK) {
                 usb_log_error("Failed to init ohci_hcd: %s.\n", str_error(rc));

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

@@ -48 +48 @@
  *
  * @param[in] dev Device asking for the addresses.
- * @param[out] mem_reg_address Base address of the memory range.
- * @param[out] mem_reg_size Size of the memory range.
+ * @param[out] p_regs Pointer to register range.
  * @param[out] irq_no IRQ assigned to the device.
  * @return Error code.
  */
-int get_my_registers(ddf_dev_t *dev,
-    uintptr_t *mem_reg_address, size_t *mem_reg_size, int *irq_no)
+int get_my_registers(ddf_dev_t *dev, addr_range_t *p_regs, int *irq_no)
 {
         assert(dev);
@@ -66 +64 @@
         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);
+        const int ret = hw_res_get_list_parsed(parent_sess, &hw_res, 0);
         async_hangup(parent_sess);
         if (ret != EOK) {
@@ -78 +76 @@
         }
 
-        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 (p_regs)
+                *p_regs = hw_res.mem_ranges.ranges[0];
         if (irq_no)
                 *irq_no = hw_res.irqs.irqs[0];

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

@@ -36 +36 @@
 
 #include <ddf/driver.h>
+#include <device/hw_res_parsed.h>
 
-int get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
+int get_my_registers(ddf_dev_t *, addr_range_t *, int *);
 int enable_interrupts(ddf_dev_t *);
 

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

@@ -105 +105 @@
  * @param[out] cmds Commands buffer.
  * @param[in] cmds_size Size of the commands buffer (bytes).
- * @param[in] regs Physical address of device's registers.
- * @param[in] reg_size Size of the register area (bytes).
+ * @param[in] regs Device's register range.
  *
  * @return Error code.
@@ -112 +111 @@
 int
 hc_get_irq_code(irq_pio_range_t ranges[], size_t ranges_size, irq_cmd_t cmds[],
-    size_t cmds_size, uintptr_t regs, size_t reg_size)
+    size_t cmds_size, addr_range_t *regs)
 {
         if ((ranges_size < sizeof(uhci_irq_pio_ranges)) ||
             (cmds_size < sizeof(uhci_irq_commands)) ||
-            (reg_size < sizeof(uhci_regs_t)))
+            (RNGSZ(*regs) < sizeof(uhci_regs_t)))
                 return EOVERFLOW;
 
         memcpy(ranges, uhci_irq_pio_ranges, sizeof(uhci_irq_pio_ranges));
-        ranges[0].base = regs;
+        ranges[0].base = RNGABS(*regs);
 
         memcpy(cmds, uhci_irq_commands, sizeof(uhci_irq_commands));
-        uhci_regs_t *registers = (uhci_regs_t *) regs;
+        uhci_regs_t *registers = (uhci_regs_t *) RNGABSPTR(*regs);
         cmds[0].addr = &registers->usbsts;
         cmds[3].addr = &registers->usbsts;
@@ -133 +132 @@
  *
  * @param[in] device Host controller DDF device
- * @param[in] reg_base Register range base
- * @param[in] reg_size Register range size
+ * @param[in] regs Register range
  * @param[in] irq Interrupt number
  * @paran[in] handler Interrupt handler
@@ -140 +138 @@
  * @return EOK on success or negative error code
  */
-int hc_register_irq_handler(ddf_dev_t *device, uintptr_t reg_base, size_t reg_size,
-    int irq, interrupt_handler_t handler)
+int hc_register_irq_handler(ddf_dev_t *device, addr_range_t *regs, int irq,
+    interrupt_handler_t handler)
 {
         int rc;
@@ -147 +145 @@
         irq_cmd_t irq_cmds[hc_irq_cmd_count];
         rc = hc_get_irq_code(irq_ranges, sizeof(irq_ranges), irq_cmds,
-            sizeof(irq_cmds), reg_base, reg_size);
+            sizeof(irq_cmds), regs);
         if (rc != EOK) {
                 usb_log_error("Failed to generate IRQ commands: %s.\n",
@@ -232 +230 @@
  *
  * @param[in] instance Memory place to initialize.
- * @param[in] regs Address of I/O control registers.
- * @param[in] reg_size Size of I/O control registers.
+ * @param[in] regs Range of device's I/O control registers.
  * @param[in] interrupts True if hw interrupts should be used.
  * @return Error code.
@@ -241 +238 @@
  * interrupt fibrils.
  */
-int hc_init(hc_t *instance, void *regs, size_t reg_size, bool interrupts)
-{
-        assert(reg_size >= sizeof(uhci_regs_t));
+int hc_init(hc_t *instance, addr_range_t *regs, bool interrupts)
+{
+        assert(regs->size >= sizeof(uhci_regs_t));
         int rc;
 
@@ -251 +248 @@
         /* allow access to hc control registers */
         uhci_regs_t *io;
-        rc = pio_enable(regs, reg_size, (void **)&io);
+        rc = pio_enable_range(regs, (void **) &io);
         if (rc != EOK) {
                 usb_log_error("Failed to gain access to registers at %p: %s.\n",
@@ -260 +257 @@
         instance->registers = io;
         usb_log_debug(
-            "Device registers at %p (%zuB) accessible.\n", io, reg_size);
+            "Device registers at %p (%zuB) accessible.\n", io, regs->size);
 
         rc = hc_init_mem_structures(instance);

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

@@ -37 +37 @@
 
 #include <ddf/interrupt.h>
+#include <device/hw_res_parsed.h>
 #include <fibril.h>
 #include <usb/host/hcd.h>
@@ -120 +121 @@
 } hc_t;
 
-int hc_register_irq_handler(ddf_dev_t *, uintptr_t, size_t, int, interrupt_handler_t);
-int hc_get_irq_code(irq_pio_range_t [], size_t, irq_cmd_t [], size_t, uintptr_t,
-    size_t);
+int hc_register_irq_handler(ddf_dev_t *, addr_range_t *, int,
+    interrupt_handler_t);
+int hc_get_irq_code(irq_pio_range_t [], size_t, irq_cmd_t [], size_t,
+    addr_range_t *);
 void hc_interrupt(hc_t *instance, uint16_t status);
-int hc_init(hc_t *instance, void *regs, size_t reg_size, bool interupts);
+int hc_init(hc_t *instance, addr_range_t *regs, bool interupts);
 
 /** Safely dispose host controller internal structures
@@ -132 +134 @@
 static inline void hc_fini(hc_t *instance) {} /* TODO: implement*/
 #endif
+
 /**
  * @}

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

@@ -46 +46 @@
  *
  * @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] io_regs_p Pointer to register I/O range.
  * @param[out] irq_no IRQ assigned to the device.
  * @return Error code.
  */
-int get_my_registers(ddf_dev_t *dev,
-    uintptr_t *io_reg_address, size_t *io_reg_size, int *irq_no)
+int get_my_registers(ddf_dev_t *dev, addr_range_t *io_regs_p, int *irq_no)
 {
         assert(dev);
@@ -76 +74 @@
         }
 
-        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 (io_regs_p)
+                *io_regs_p = hw_res.io_ranges.ranges[0];
         if (irq_no)
                 *irq_no = hw_res.irqs.irqs[0];

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

@@ -37 +37 @@
 
 #include <ddf/driver.h>
+#include <device/hw_res_parsed.h>
 
-int get_my_registers(ddf_dev_t *, uintptr_t *, size_t *, int *);
+int get_my_registers(ddf_dev_t *, addr_range_t *, int *);
 int enable_interrupts(ddf_dev_t *);
 int disable_legacy(ddf_dev_t *);

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

@@ -184 +184 @@
         ddf_fun_data_implant(instance->rh_fun, &instance->rh);
 
-        uintptr_t reg_base = 0;
-        size_t reg_size = 0;
+        addr_range_t regs;
         int irq = 0;
 
-        rc = get_my_registers(device, &reg_base, &reg_size, &irq);
+        rc = get_my_registers(device, &regs, &irq);
         if (rc != EOK) {
                 usb_log_error("Failed to get I/O addresses for %" PRIun ": %s.\n",
@@ -194 +193 @@
                 goto error;
         }
-        usb_log_debug("I/O regs at 0x%p (size %zu), IRQ %d.\n",
-            (void *) reg_base, reg_size, irq);
+        usb_log_debug("I/O regs at %p (size %zu), IRQ %d.\n",
+            RNGABSPTR(regs), RNGSZ(regs), irq);
 
         rc = disable_legacy(device);
@@ -204 +203 @@
         }
 
-        rc = hc_register_irq_handler(device, reg_base, reg_size, irq, irq_handler);
+        rc = hc_register_irq_handler(device, &regs, irq, irq_handler);
         if (rc != EOK) {
                 usb_log_error("Failed to register interrupt handler: %s.\n",
@@ -223 +222 @@
         }
 
-        rc = hc_init(&instance->hc, (void*)reg_base, reg_size, interrupts);
+        rc = hc_init(&instance->hc, &regs, interrupts);
         if (rc != EOK) {
                 usb_log_error("Failed to init uhci_hcd: %s.\n", str_error(rc));

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

@@ -92 +92 @@
  */
 static inline void free32(void *addr)
-        { free(addr); }
+{
+        free(addr);
+}
 
 /** Create 4KB page mapping
@@ -98 +100 @@
  * @return Address of the mapped page, NULL on failure.
  */
-static inline void * get_page(void)
+static inline void *get_page(void)
 {
-        void *address, *phys;
+        uintptr_t phys;
+        void *address;
+        
         const int ret = dmamem_map_anonymous(UHCI_REQUIRED_PAGE_SIZE,
-            AS_AREA_READ | AS_AREA_WRITE, 0, &phys, &address);
-        return ret == EOK ? address : NULL;
+            DMAMEM_4GiB, AS_AREA_READ | AS_AREA_WRITE, 0, &phys,
+            &address);
+        
+        return ((ret == EOK) ? address : NULL);
 }
 

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

@@ -48 +48 @@
 #define NAME "uhcirh"
 
-static int hc_get_my_registers(ddf_dev_t *dev,
-    uintptr_t *io_reg_address, size_t *io_reg_size);
+static int hc_get_my_registers(ddf_dev_t *dev, addr_range_t *io_regs);
 
 static int uhci_rh_dev_add(ddf_dev_t *device);
@@ -90 +89 @@
             ddf_dev_get_handle(device));
 
-        uintptr_t io_regs = 0;
-        size_t io_size = 0;
+        addr_range_t regs;
         uhci_root_hub_t *rh = NULL;
         int rc;
 
-        rc = hc_get_my_registers(device, &io_regs, &io_size);
+        rc = hc_get_my_registers(device, &regs);
         if (rc != EOK) {
                 usb_log_error( "Failed to get registers from HC: %s.\n",
@@ -103 +101 @@
 
         usb_log_debug("I/O regs at %p (size %zuB).\n",
-            (void *) io_regs, io_size);
+            RNGABSPTR(regs), RNGSZ(regs));
 
         rh = ddf_dev_data_alloc(device, sizeof(uhci_root_hub_t));
@@ -111 +109 @@
         }
 
-        rc = uhci_root_hub_init(rh, (void*)io_regs, io_size, device);
+        rc = uhci_root_hub_init(rh, &regs, device);
         if (rc != EOK) {
                 usb_log_error("Failed(%d) to initialize rh driver instance: "
@@ -127 +125 @@
  *
  * @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.
+ * @param[out] io_regs_p Pointer to the device's register range.
  * @return Error code.
  */
-int hc_get_my_registers(
-    ddf_dev_t *dev, uintptr_t *io_reg_address, size_t *io_reg_size)
+int hc_get_my_registers(ddf_dev_t *dev, addr_range_t *io_regs_p)
 {
         async_sess_t *parent_sess =
@@ -153 +149 @@
         }
 
-        if (io_reg_address != NULL)
-                *io_reg_address = hw_res.io_ranges.ranges[0].address;
-
-        if (io_reg_size != NULL)
-                *io_reg_size = hw_res.io_ranges.ranges[0].size;
+        if (io_regs_p != NULL)
+                *io_regs_p = hw_res.io_ranges.ranges[0];
 
         hw_res_list_parsed_clean(&hw_res);

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

@@ -36 +36 @@
 #include <ddi.h>
 #include <usb/debug.h>
+#include <device/hw_res_parsed.h>
 
 #include "root_hub.h"
@@ -42 +43 @@
  *
  * @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] io_regs Range of I/O registers.
  * @param[in] rh Pointer to DDF instance of 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)
+int uhci_root_hub_init(uhci_root_hub_t *instance, addr_range_t *io_regs,
+    ddf_dev_t *rh)
 {
+        port_status_t *regs;
+
         assert(instance);
         assert(rh);
 
         /* Allow access to root hub port registers */
-        assert(sizeof(port_status_t) * UHCI_ROOT_HUB_PORT_COUNT <= size);
-        port_status_t *regs;
-        int ret = pio_enable(addr, size, (void**)&regs);
+        assert(sizeof(*regs) * UHCI_ROOT_HUB_PORT_COUNT <= io_regs->size);
+
+        int ret = pio_enable_range(io_regs, (void **) &regs);
         if (ret < 0) {
                 usb_log_error(
                     "Failed(%d) to gain access to port registers at %p: %s.\n",
-                    ret, regs, str_error(ret));
+                    ret, RNGABSPTR(*io_regs), str_error(ret));
                 return ret;
         }

uspace/drv/bus/usb/uhcirh/root_hub.h

@@ -36 +36 @@
 
 #include <ddf/driver.h>
+#include <device/hw_res_parsed.h>
 
 #include "port.h"
@@ -48 +49 @@
 } uhci_root_hub_t;
 
-int uhci_root_hub_init(
-    uhci_root_hub_t *instance, void *addr, size_t size, ddf_dev_t *rh);
+int uhci_root_hub_init(uhci_root_hub_t *instance, addr_range_t *regs,
+    ddf_dev_t *rh);
 
 void uhci_root_hub_fini(uhci_root_hub_t *instance);

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

@@ -56 +56 @@
 static bool interface_in_list(const list_t *list, int interface_no)
 {
-        list_foreach(*list, l) {
-                usbmid_interface_t *iface = usbmid_interface_from_link(l);
+        list_foreach(*list, link, usbmid_interface_t, iface) {
                 if (iface->interface_no == interface_no) {
                         return true;
@@ -190 +189 @@
 
         /* Start child function for every interface. */
-        list_foreach(usb_mid->interface_list, link) {
-                usbmid_interface_t *iface = usbmid_interface_from_link(link);
-
+        list_foreach(usb_mid->interface_list, link, usbmid_interface_t, iface) {
                 usb_log_info("Creating child for interface %d (%s).\n",
                     iface->interface_no,

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

@@ -135 +135 @@
         }
 
-        list_foreach(match_ids.ids, link) {
-                match_id_t *match_id = list_get_instance(link, match_id_t, link);
+        list_foreach(match_ids.ids, link, match_id_t, match_id) {
                 rc = ddf_fun_add_match_id(child, match_id->id, match_id->score);
                 if (rc != EOK) {

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

@@ -92 +92 @@
 
         bool target_found = false;
-        list_foreach(vhc->devices, pos) {
-                vhc_virtdev_t *dev = list_get_instance(pos, vhc_virtdev_t, link);
+        list_foreach(vhc->devices, link, vhc_virtdev_t, dev) {
                 fibril_mutex_lock(&dev->guard);
                 if (dev->address == transfer->address) {