Index: uspace/drv/bus/usb/ehci/main.c
===================================================================
--- uspace/drv/bus/usb/ehci/main.c	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/ehci/main.c	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -77,9 +77,8 @@
 	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,8 +87,8 @@
 	}
 
-	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",
Index: uspace/drv/bus/usb/ehci/res.c
===================================================================
--- uspace/drv/bus/usb/ehci/res.c	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/ehci/res.c	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -71,11 +71,10 @@
  *
  * @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,8 +98,6 @@
 	}
 
-	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,5 +264,5 @@
 }
 
-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,8 +271,8 @@
 	/* 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;
 	}
Index: uspace/drv/bus/usb/ehci/res.h
===================================================================
--- uspace/drv/bus/usb/ehci/res.h	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/ehci/res.h	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -37,8 +37,9 @@
 
 #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
Index: uspace/drv/bus/usb/ohci/hc.c
===================================================================
--- uspace/drv/bus/usb/ohci/hc.c	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/ohci/hc.c	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -106,6 +106,5 @@
  * @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,16 +112,16 @@
 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,6 +134,5 @@
  *
  * @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,6 +140,6 @@
  * @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,5 +156,5 @@
 
 	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,15 +257,13 @@
  *
  * @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",
Index: uspace/drv/bus/usb/ohci/hc.h
===================================================================
--- uspace/drv/bus/usb/ohci/hc.h	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/ohci/hc.h	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -75,9 +75,10 @@
 } 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
Index: uspace/drv/bus/usb/ohci/ohci.c
===================================================================
--- uspace/drv/bus/usb/ohci/ohci.c	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/ohci/ohci.c	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -177,9 +177,8 @@
 	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,7 +189,7 @@
 
 	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,5 +214,5 @@
 	}
 
-	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));
Index: uspace/drv/bus/usb/ohci/res.c
===================================================================
--- uspace/drv/bus/usb/ohci/res.c	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/ohci/res.c	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -48,11 +48,9 @@
  *
  * @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,5 +64,5 @@
 	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,8 +76,6 @@
 	}
 
-	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];
Index: uspace/drv/bus/usb/ohci/res.h
===================================================================
--- uspace/drv/bus/usb/ohci/res.h	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/ohci/res.h	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -36,6 +36,7 @@
 
 #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 *);
 
Index: uspace/drv/bus/usb/uhci/hc.c
===================================================================
--- uspace/drv/bus/usb/uhci/hc.c	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/uhci/hc.c	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -105,6 +105,5 @@
  * @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,16 +111,16 @@
 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,6 +132,5 @@
  *
  * @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,6 +138,6 @@
  * @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,5 +145,5 @@
 	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,6 +230,5 @@
  *
  * @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,7 +238,7 @@
  * 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,5 +248,5 @@
 	/* 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,5 +257,5 @@
 	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);
Index: uspace/drv/bus/usb/uhci/hc.h
===================================================================
--- uspace/drv/bus/usb/uhci/hc.h	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/uhci/hc.h	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -37,4 +37,5 @@
 
 #include <ddf/interrupt.h>
+#include <device/hw_res_parsed.h>
 #include <fibril.h>
 #include <usb/host/hcd.h>
@@ -120,9 +121,10 @@
 } 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,4 +134,5 @@
 static inline void hc_fini(hc_t *instance) {} /* TODO: implement*/
 #endif
+
 /**
  * @}
Index: uspace/drv/bus/usb/uhci/res.c
===================================================================
--- uspace/drv/bus/usb/uhci/res.c	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/uhci/res.c	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -46,11 +46,9 @@
  *
  * @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,8 +74,6 @@
 	}
 
-	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];
Index: uspace/drv/bus/usb/uhci/res.h
===================================================================
--- uspace/drv/bus/usb/uhci/res.h	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/uhci/res.h	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -37,6 +37,7 @@
 
 #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 *);
Index: uspace/drv/bus/usb/uhci/uhci.c
===================================================================
--- uspace/drv/bus/usb/uhci/uhci.c	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/uhci/uhci.c	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -184,9 +184,8 @@
 	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,6 +193,6 @@
 		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,5 +203,5 @@
 	}
 
-	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,5 +222,5 @@
 	}
 
-	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));
Index: uspace/drv/bus/usb/uhcirh/main.c
===================================================================
--- uspace/drv/bus/usb/uhcirh/main.c	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/uhcirh/main.c	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -48,6 +48,5 @@
 #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,10 +89,9 @@
 	    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,5 +101,5 @@
 
 	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,5 +109,5 @@
 	}
 
-	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,10 +125,8 @@
  *
  * @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,9 +149,6 @@
 	}
 
-	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);
Index: uspace/drv/bus/usb/uhcirh/root_hub.c
===================================================================
--- uspace/drv/bus/usb/uhcirh/root_hub.c	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/uhcirh/root_hub.c	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -36,4 +36,5 @@
 #include <ddi.h>
 #include <usb/debug.h>
+#include <device/hw_res_parsed.h>
 
 #include "root_hub.h"
@@ -42,23 +43,24 @@
  *
  * @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;
 	}
Index: uspace/drv/bus/usb/uhcirh/root_hub.h
===================================================================
--- uspace/drv/bus/usb/uhcirh/root_hub.h	(revision 46eb2c4eee45c63d2a2d1ef420c1917ec6c890fa)
+++ uspace/drv/bus/usb/uhcirh/root_hub.h	(revision 7de1988cde59f3ad2459d423b31be5ea19d7df75)
@@ -36,4 +36,5 @@
 
 #include <ddf/driver.h>
+#include <device/hw_res_parsed.h>
 
 #include "port.h"
@@ -48,6 +49,6 @@
 } 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);