Index: uspace/lib/c/Makefile
===================================================================
--- uspace/lib/c/Makefile	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/Makefile	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -57,4 +57,7 @@
 	generic/clipboard.c \
 	generic/devmap.c \
+	generic/devman.c \
+	generic/device/hw_res.c \
+	generic/device/char.c \
 	generic/event.c \
 	generic/errno.c \
Index: uspace/lib/c/arch/abs32le/include/istate.h
===================================================================
--- uspace/lib/c/arch/abs32le/include/istate.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/arch/abs32le/include/istate.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -36,26 +36,5 @@
 #define LIBC_abs32le__ISTATE_H_
 
-#include <sys/types.h>
-
-/** Interrupt context.
- *
- * On real hardware this stores the registers which
- * need to be preserved during interupts.
- */
-typedef struct istate {
-	uintptr_t ip;
-	uintptr_t fp;
-	uint32_t stack[];
-} istate_t;
-
-static inline uintptr_t istate_get_pc(istate_t *istate)
-{
-	return istate->ip;
-}
-
-static inline uintptr_t istate_get_fp(istate_t *istate)
-{
-	return istate->fp;
-}
+#include <arch/istate.h>
 
 #endif
Index: uspace/lib/c/arch/amd64/include/istate.h
===================================================================
--- uspace/lib/c/arch/amd64/include/istate.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/arch/amd64/include/istate.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -36,37 +36,5 @@
 #define LIBC_amd64_ISTATE_H_
 
-#include <sys/types.h>
-
-/** Interrupt context.
- *
- * This is a copy of the kernel definition with which it must be kept in sync.
- */
-typedef struct istate {
-	uint64_t rax;
-	uint64_t rcx;
-	uint64_t rdx;
-	uint64_t rsi;
-	uint64_t rdi;
-	uint64_t r8;
-	uint64_t r9;
-	uint64_t r10;
-	uint64_t r11;
-	uint64_t rbp;
-	uint64_t error_word;
-	uint64_t rip;
-	uint64_t cs;
-	uint64_t rflags;
-	uint64_t stack[]; /* Additional data on stack */
-} istate_t;
-
-static inline uintptr_t istate_get_pc(istate_t *istate)
-{
-	return istate->rip;
-}
-
-static inline uintptr_t istate_get_fp(istate_t *istate)
-{
-	return istate->rbp;
-}
+#include <arch/istate.h>
 
 #endif
Index: uspace/lib/c/arch/amd64/src/entry.s
===================================================================
--- uspace/lib/c/arch/amd64/src/entry.s	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/arch/amd64/src/entry.s	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -42,5 +42,5 @@
 	#
 	pushq $0
-	mov %rsp, %rbp
+	movq %rsp, %rbp
 	
 	# %rdi was deliberately chosen as the first argument is also in %rdi
Index: uspace/lib/c/arch/amd64/src/fibril.S
===================================================================
--- uspace/lib/c/arch/amd64/src/fibril.S	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/arch/amd64/src/fibril.S	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -49,6 +49,6 @@
 	movq %rax, OFFSET_TLS(%rdi)
 		
-	xorq %rax,%rax		# context_save returns 1
-	incq %rax
+	xorl %eax, %eax		# context_save returns 1
+	incl %eax
 	ret
 
@@ -67,7 +67,7 @@
 	# Set thread local storage
 	movq OFFSET_TLS(%rdi), %rdi   # Set arg1 to TLS addr
-	movq $1, %rax		# SYS_TLS_SET
+	movl $1, %eax		# SYS_TLS_SET
 	syscall
 
-	xorq %rax,%rax		# context_restore returns 0
+	xorl %eax, %eax		# context_restore returns 0
 	ret
Index: uspace/lib/c/arch/arm32/include/istate.h
===================================================================
--- uspace/lib/c/arch/arm32/include/istate.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/arch/arm32/include/istate.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -36,41 +36,5 @@
 #define LIBC_arm32__ISTATE_H_
 
-#include <sys/types.h>
-
-/** Interrupt context.
- *
- * This is a copy of the kernel definition with which it must be kept in sync.
- */
-typedef struct istate {
-	uint32_t spsr;
-	uint32_t sp;
-	uint32_t lr;
-
-	uint32_t r0;
-	uint32_t r1;
-	uint32_t r2;
-	uint32_t r3;
-	uint32_t r4;
-	uint32_t r5;
-	uint32_t r6;
-	uint32_t r7;
-	uint32_t r8;
-	uint32_t r9;
-	uint32_t r10;
-	uint32_t fp;
-	uint32_t r12;
-
-	uint32_t pc;
-} istate_t;
-
-static inline uintptr_t istate_get_pc(istate_t *istate)
-{
-	return istate->pc;
-}
-
-static inline uintptr_t istate_get_fp(istate_t *istate)
-{
-	return istate->fp;
-}
+#include <arch/istate.h>
 
 #endif
Index: uspace/lib/c/arch/ia32/include/istate.h
===================================================================
--- uspace/lib/c/arch/ia32/include/istate.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/arch/ia32/include/istate.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -36,37 +36,5 @@
 #define LIBC_ia32__ISTATE_H_
 
-#include <sys/types.h>
-
-/** Interrupt context.
- *
- * This is a copy of the kernel definition with which it must be kept in sync.
- */
-typedef struct istate {
-	uint32_t eax;
-	uint32_t ecx;
-	uint32_t edx;
-	uint32_t ebp;
-
-	uint32_t gs;
-	uint32_t fs;
-	uint32_t es;
-	uint32_t ds;
-
-	uint32_t error_word;
-	uint32_t eip;
-	uint32_t cs;
-	uint32_t eflags;
-	uint32_t stack[];
-} istate_t;
-
-static inline uintptr_t istate_get_pc(istate_t *istate)
-{
-	return istate->eip;
-}
-
-static inline uintptr_t istate_get_fp(istate_t *istate)
-{
-	return istate->ebp;
-}
+#include <arch/istate.h>
 
 #endif
Index: uspace/lib/c/arch/ia64/include/istate.h
===================================================================
--- uspace/lib/c/arch/ia64/include/istate.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/arch/ia64/include/istate.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -36,25 +36,5 @@
 #define LIBC_ia64_ISTATE_H_
 
-#include <sys/types.h>
-
-/** Interrupt context.
- *
- * This is a copy of the kernel definition with which it must be kept in sync.
- */
-typedef struct istate {
-	/* TODO */
-} istate_t;
-
-static inline uintptr_t istate_get_pc(istate_t *istate)
-{
-	/* TODO */
-	return 0;
-}
-
-static inline uintptr_t istate_get_fp(istate_t *istate)
-{
-	/* TODO */
-	return 0;
-}
+#include <arch/istate.h>
 
 #endif
Index: uspace/lib/c/arch/mips32/include/istate.h
===================================================================
--- uspace/lib/c/arch/mips32/include/istate.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/arch/mips32/include/istate.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -36,50 +36,5 @@
 #define LIBC_mips32__ISTATE_H_
 
-#include <sys/types.h>
-
-/** Interrupt context.
- *
- * This is a copy of the kernel definition with which it must be kept in sync.
- */
-typedef struct istate {
-	uint32_t at;
-	uint32_t v0;
-	uint32_t v1;
-	uint32_t a0;
-	uint32_t a1;
-	uint32_t a2;
-	uint32_t a3;
-	uint32_t t0;
-	uint32_t t1;
-	uint32_t t2;
-	uint32_t t3;
-	uint32_t t4;
-	uint32_t t5;
-	uint32_t t6;
-	uint32_t t7;
-	uint32_t t8;
-	uint32_t t9;
-	uint32_t gp;
-	uint32_t sp;
-	uint32_t ra;
-
-	uint32_t lo;
-	uint32_t hi;
-
-	uint32_t status; /* cp0_status */
-	uint32_t epc; /* cp0_epc */
-	uint32_t k1; /* We use it as thread-local pointer */
-} istate_t;
-
-static inline uintptr_t istate_get_pc(istate_t *istate)
-{
-	return istate->epc;
-}
-
-static inline uintptr_t istate_get_fp(istate_t *istate)
-{
-	/* TODO */
-	return 0;
-}
+#include <arch/istate.h>
 
 #endif
Index: uspace/lib/c/arch/sparc64/include/istate.h
===================================================================
--- uspace/lib/c/arch/sparc64/include/istate.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/arch/sparc64/include/istate.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -36,25 +36,5 @@
 #define LIBC_sparc64_ISTATE_H_
 
-#include <sys/types.h>
-
-/** Interrupt context.
- *
- * This is a copy of the kernel definition with which it must be kept in sync.
- */
-typedef struct istate {
-	/* TODO */
-} istate_t;
-
-static inline uintptr_t istate_get_pc(istate_t *istate)
-{
-	/* TODO */
-	return 0;
-}
-
-static inline uintptr_t istate_get_fp(istate_t *istate)
-{
-	/* TODO */
-	return 0;
-}
+#include <arch/istate.h>
 
 #endif
Index: uspace/lib/c/generic/adt/dynamic_fifo.c
===================================================================
--- uspace/lib/c/generic/adt/dynamic_fifo.c	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/generic/adt/dynamic_fifo.c	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -28,5 +28,5 @@
 
 /** @addtogroup libc
- *  @{
+ * @{
  */
 
@@ -34,10 +34,10 @@
  * Dynamic first in first out positive integer queue implementation.
  */
+
+#include <adt/dynamic_fifo.h>
 
 #include <errno.h>
 #include <malloc.h>
 #include <mem.h>
-
-#include <adt/dynamic_fifo.h>
 
 /** Internal magic value for a consistency check. */
@@ -106,5 +106,5 @@
 int dyn_fifo_push(dyn_fifo_ref fifo, int value, int max_size)
 {
-	int * new_items;
+	int *new_items;
 
 	if (!dyn_fifo_is_valid(fifo))
@@ -149,5 +149,5 @@
 /** Returns and excludes the first item in the queue.
  *
- * @param[in,out] fifoi	The dynamic queue.
+ * @param[in,out] fifo	The dynamic queue.
  * @returns		Value of the first item in the queue.
  * @returns		EINVAL if the queue is not valid.
@@ -189,7 +189,7 @@
 /** Clears and destroys the queue.
  *
- *  @param[in,out] fifo		The dynamic queue.
- *  @returns			EOK on success.
- *  @returns			EINVAL if the queue is not valid.
+ * @param[in,out] fifo	The dynamic queue.
+ * @returns		EOK on success.
+ * @returns		EINVAL if the queue is not valid.
  */
 int dyn_fifo_destroy(dyn_fifo_ref fifo)
Index: uspace/lib/c/generic/adt/measured_strings.c
===================================================================
--- uspace/lib/c/generic/adt/measured_strings.c	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/generic/adt/measured_strings.c	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -52,7 +52,7 @@
  * @param[in] string	The initial character string to be stored.
  * @param[in] length	The length of the given string without the terminating
- *			zero ('/0') character. If the length is zero (0), the
- *			actual length is computed. The given length is used and
- *			appended with the terminating zero ('\\0') character
+ *			zero ('\0') character. If the length is zero, the actual
+ *			length is computed. The given length is used and
+ *			appended with the terminating zero ('\0') character
  *			otherwise.
  * @returns		The new bundled character string with measured length.
@@ -60,5 +60,5 @@
  */
 measured_string_ref
-measured_string_create_bulk(const char * string, size_t length)
+measured_string_create_bulk(const char *string, size_t length)
 {
 	measured_string_ref new;
@@ -66,5 +66,5 @@
 	if (length == 0) {
 		while (string[length])
-			++length;
+			length++;
 	}
 	new = (measured_string_ref) malloc(sizeof(measured_string_t) +
@@ -104,7 +104,6 @@
 			new->value[new->length] = '\0';
 			return new;
-		} else {
-			free(new);
 		}
+		free(new);
 	}
 
@@ -156,6 +155,6 @@
 		return EINVAL;
 	}
-	if(ERROR_OCCURRED(async_data_write_finalize(callid, lengths,
-	    sizeof(size_t) * (count + 1)))) {
+	if (ERROR_OCCURRED(async_data_write_finalize(callid, lengths,
+	    length))) {
 		free(lengths);
 		return ERROR_CODE;
@@ -163,5 +162,5 @@
 
 	*data = malloc(lengths[count]);
-	if (!(*data)) {
+	if (!*data) {
 		free(lengths);
 		return ENOMEM;
@@ -171,5 +170,5 @@
 	*strings = (measured_string_ref) malloc(sizeof(measured_string_t) *
 	    count);
-	if (!(*strings)) {
+	if (!*strings) {
 		free(lengths);
 		free(*data);
@@ -178,8 +177,8 @@
 
 	next = *data;
-	for (index = 0; index < count; ++index) {
+	for (index = 0; index < count; index++) {
 		(*strings)[index].length = lengths[index];
 		if (lengths[index] > 0) {
-			if ((!async_data_write_receive(&callid, &length)) ||
+			if (!async_data_write_receive(&callid, &length) ||
 			    (length != lengths[index])) {
 				free(*data);
@@ -188,10 +187,14 @@
 				return EINVAL;
 			}
-			ERROR_PROPAGATE(async_data_write_finalize(callid, next,
-			    lengths[index]));
+			if (ERROR_OCCURRED(async_data_write_finalize(callid,
+			    next, lengths[index]))) {
+				free(*data);
+				free(*strings);
+				free(lengths);
+				return ERROR_CODE;
+			}
 			(*strings)[index].value = next;
 			next += lengths[index];
-			*next = '\0';
-			++next;
+			*next++ = '\0';
 		} else {
 			(*strings)[index].value = NULL;
@@ -221,5 +224,5 @@
 
 	length = 0;
-	for (index = 0; index < count; ++ index) {
+	for (index = 0; index < count; index++) {
 		lengths[index] = strings[index].length;
 		length += lengths[index] + 1;
@@ -262,11 +265,10 @@
 		return ENOMEM;
 
-	if ((!async_data_read_receive(&callid, &length)) ||
+	if (!async_data_read_receive(&callid, &length) ||
 	    (length != sizeof(size_t) * (count + 1))) {
 		free(lengths);
 		return EINVAL;
 	}
-	if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths,
-	    sizeof(size_t) * (count + 1)))) {
+	if (ERROR_OCCURRED(async_data_read_finalize(callid, lengths, length))) {
 		free(lengths);
 		return ERROR_CODE;
@@ -274,7 +276,7 @@
 	free(lengths);
 
-	for (index = 0; index < count; ++ index) {
+	for (index = 0; index < count; index++) {
 		if (strings[index].length > 0) {
-			if((!async_data_read_receive(&callid, &length))	||
+			if (!async_data_read_receive(&callid, &length) ||
 			    (length != strings[index].length)) {
 				return EINVAL;
@@ -317,5 +319,5 @@
 	char *next;
 
-	if ((phone <= 0) || (!strings) || (!data) || (count <= 0))
+	if ((phone < 0) || (!strings) || (!data) || (count <= 0))
 		return EINVAL;
 
@@ -331,5 +333,5 @@
 
 	*data = malloc(lengths[count]);
-	if (!(*data)) {
+	if (!*data) {
 		free(lengths);
 		return ENOMEM;
@@ -338,5 +340,5 @@
 	*strings = (measured_string_ref) malloc(sizeof(measured_string_t) *
 	    count);
-	if (!(*strings)) {
+	if (!*strings) {
 		free(lengths);
 		free(*data);
@@ -345,13 +347,17 @@
 
 	next = *data;
-	for (index = 0; index < count; ++ index) {
+	for (index = 0; index < count; index++) {
 		(*strings)[index].length = lengths[index];
 		if (lengths[index] > 0) {
-			ERROR_PROPAGATE(async_data_read_start(phone, next,
-			    lengths[index]));
+			if (ERROR_OCCURRED(async_data_read_start(phone, next,
+			    lengths[index]))) {
+			    	free(lengths);
+				free(data);
+				free(strings);
+				return ERROR_CODE;
+			}
 			(*strings)[index].value = next;
 			next += lengths[index];
-			*next = '\0';
-			++ next;
+			*next++ = '\0';
 		} else {
 			(*strings)[index].value = NULL;
@@ -386,5 +392,5 @@
 	size_t index;
 
-	if ((phone <= 0) || (!strings) || (count <= 0))
+	if ((phone < 0) || (!strings) || (count <= 0))
 		return EINVAL;
 
@@ -401,5 +407,5 @@
 	free(lengths);
 
-	for (index = 0; index < count; ++index) {
+	for (index = 0; index < count; index++) {
 		if (strings[index].length > 0) {
 			ERROR_PROPAGATE(async_data_write_start(phone,
Index: uspace/lib/c/generic/ddi.c
===================================================================
--- uspace/lib/c/generic/ddi.c	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/generic/ddi.c	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -96,4 +96,26 @@
 }
 
+/** Enable an interrupt.
+ * 
+ * @param irq the interrupt.
+ * 
+ * @return Zero on success, negative error code otherwise. 
+ */
+int interrupt_enable(int irq) 
+{
+	return __SYSCALL2(SYS_INTERRUPT_ENABLE, (sysarg_t) irq, 1);
+}
+
+/** Disable an interrupt.
+ * 
+ * @param irq the interrupt.
+ * 
+ * @return Zero on success, negative error code otherwise. 
+ */
+int interrupt_disable(int irq) 
+{
+	return __SYSCALL2(SYS_INTERRUPT_ENABLE, (sysarg_t) irq, 0);
+}
+
 /** Enable PIO for specified I/O range.
  *
Index: uspace/lib/c/generic/device/char.c
===================================================================
--- uspace/lib/c/generic/device/char.c	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
+++ uspace/lib/c/generic/device/char.c	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -0,0 +1,123 @@
+/*
+ * Copyright (c) 2010 Lenka Trochtova
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+ 
+ /** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+
+#include <ipc/dev_iface.h>
+#include <device/char.h>
+#include <errno.h>
+#include <async.h>
+#include <malloc.h>
+#include <stdio.h>
+
+/** Read to or write from the device using its character interface.
+ * 
+ * Helper function.
+ * 
+ * @param dev_phone phone to the device.
+ * @param buf the buffer for the data read from or written to the device.
+ * @param len the maximum length of the data to be read or written.
+ * @param read read from the device if true, write to it otherwise.
+ * 
+ * @return non-negative number of bytes actually read from or written to the device on success,
+ * negative error number otherwise.
+ * 
+ */
+static int rw_dev(int dev_phone, void *buf, size_t len, bool read) 
+{
+	ipc_call_t answer;
+	
+	async_serialize_start();
+	
+	aid_t req;
+	int ret;
+	
+	if (read) {
+		req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE), CHAR_READ_DEV, &answer);
+		ret = async_data_read_start(dev_phone, buf, len);		
+	} else {
+		req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE), CHAR_WRITE_DEV, &answer);
+		ret = async_data_write_start(dev_phone, buf, len);
+	}
+	
+	ipcarg_t rc;
+	if (ret != EOK) {		
+		async_wait_for(req, &rc);
+		async_serialize_end();
+		if (rc == EOK) {
+			return ret;
+		}
+		else {
+			return (int) rc;
+		}
+	}
+	
+	async_wait_for(req, &rc);
+	async_serialize_end();
+	
+	ret = (int)rc;
+	if (EOK != ret) {
+		return ret;
+	}
+	
+	return IPC_GET_ARG1(answer);	
+}
+
+/** Read from the device using its character interface.
+ * 
+ * @param dev_phone phone to the device.
+ * @param buf the output buffer for the data read from the device.
+ * @param len the maximum length of the data to be read.
+ * 
+ * @return non-negative number of bytes actually read from the device on success, negative error number otherwise.
+ */
+int read_dev(int dev_phone, void *buf, size_t len)
+{	
+	return rw_dev(dev_phone, buf, len, true);
+}
+
+/** Write to the device using its character interface.
+ * 
+ * @param dev_phone phone to the device.
+ * @param buf the input buffer containg the data to be written to the device.
+ * @param len the maximum length of the data to be written.
+ * 
+ * @return non-negative number of bytes actually written to the device on success, negative error number otherwise.
+ */
+int write_dev(int dev_phone, void *buf, size_t len)
+{
+	return rw_dev(dev_phone, buf, len, false);
+}
+
+  
+ /** @}
+ */
Index: uspace/lib/c/generic/device/hw_res.c
===================================================================
--- uspace/lib/c/generic/device/hw_res.c	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
+++ uspace/lib/c/generic/device/hw_res.c	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -0,0 +1,74 @@
+/*
+ * Copyright (c) 2010 Lenka Trochtova
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+ 
+ /** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+ 
+#include <device/hw_res.h>
+#include <errno.h>
+#include <async.h>
+#include <malloc.h>
+
+bool get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources)
+{
+	ipcarg_t count = 0;
+	int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), GET_RESOURCE_LIST, &count);
+	hw_resources->count = count;
+	if (EOK != rc) {
+		return false;
+	}
+	
+	size_t size = count * sizeof(hw_resource_t);
+	hw_resources->resources = (hw_resource_t *)malloc(size);
+	if (NULL == hw_resources->resources) {
+		return false;
+	}
+	
+	rc = async_data_read_start(dev_phone, hw_resources->resources, size);
+	if (EOK != rc) {
+		free(hw_resources->resources);
+		hw_resources->resources = NULL;
+		return false;
+	}
+	 	 
+	return true;	 
+}
+
+bool enable_interrupt(int dev_phone)
+{
+	int rc = async_req_1_0(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE), ENABLE_INTERRUPT);
+	return rc == EOK;
+}
+ 
+ 
+ 
+ /** @}
+ */
Index: uspace/lib/c/generic/devman.c
===================================================================
--- uspace/lib/c/generic/devman.c	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
+++ uspace/lib/c/generic/devman.c	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -0,0 +1,294 @@
+/*
+ * Copyright (c) 2007 Josef Cejka
+ * Copyright (c) 2009 Jiri Svoboda
+ * Copyright (c) 2010 Lenka Trochtova
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+ 
+ /** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+
+#include <str.h>
+#include <stdio.h>
+#include <ipc/ipc.h>
+#include <ipc/services.h>
+#include <ipc/devman.h>
+#include <devman.h>
+#include <async.h>
+#include <errno.h>
+#include <malloc.h>
+#include <bool.h>
+#include <adt/list.h>
+
+static int devman_phone_driver = -1;
+static int devman_phone_client = -1;
+
+int devman_get_phone(devman_interface_t iface, unsigned int flags)
+{
+	switch (iface) {
+	case DEVMAN_DRIVER:
+		if (devman_phone_driver >= 0)
+			return devman_phone_driver;
+		
+		if (flags & IPC_FLAG_BLOCKING)
+			devman_phone_driver = ipc_connect_me_to_blocking(PHONE_NS,
+			    SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
+		else
+			devman_phone_driver = ipc_connect_me_to(PHONE_NS,
+			    SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
+		
+		return devman_phone_driver;
+	case DEVMAN_CLIENT:
+		if (devman_phone_client >= 0)
+			return devman_phone_client;
+		
+		if (flags & IPC_FLAG_BLOCKING)
+			devman_phone_client = ipc_connect_me_to_blocking(PHONE_NS,
+			    SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
+		else
+			devman_phone_client = ipc_connect_me_to(PHONE_NS,
+			    SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
+		
+		return devman_phone_client;
+	default:
+		return -1;
+	}
+}
+
+/** Register running driver with device manager. */
+int devman_driver_register(const char *name, async_client_conn_t conn)
+{
+	int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
+	
+	if (phone < 0)
+		return phone;
+	
+	async_serialize_start();
+	
+	ipc_call_t answer;
+	aid_t req = async_send_2(phone, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
+	
+	ipcarg_t retval = async_data_write_start(phone, name, str_size(name));
+	if (retval != EOK) {
+		async_wait_for(req, NULL);
+		async_serialize_end();
+		return -1;
+	}
+	
+	async_set_client_connection(conn);
+	
+	ipcarg_t callback_phonehash;
+	ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
+	async_wait_for(req, &retval);
+	
+	async_serialize_end();
+	
+	return retval;
+}
+
+static int devman_send_match_id(int phone, match_id_t *match_id) \
+{
+	ipc_call_t answer;
+	async_send_1(phone, DEVMAN_ADD_MATCH_ID, match_id->score, &answer);
+	int retval = async_data_write_start(phone, match_id->id, str_size(match_id->id));
+	return retval;	
+}
+
+
+static int devman_send_match_ids(int phone, match_id_list_t *match_ids) 
+{
+	link_t *link = match_ids->ids.next;
+	match_id_t *match_id = NULL;
+	int ret = EOK;
+	
+	while (link != &match_ids->ids) {
+		match_id = list_get_instance(link, match_id_t, link); 
+		if (EOK != (ret = devman_send_match_id(phone, match_id))) 
+		{
+			printf("Driver failed to send match id, error number = %d\n", ret);
+			return ret;			
+		}
+		link = link->next;
+	}
+	return ret;	
+}
+
+int devman_child_device_register(
+	const char *name, match_id_list_t *match_ids, device_handle_t parent_handle, device_handle_t *handle)
+{		
+	int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
+	
+	if (phone < 0)
+		return phone;
+	
+	async_serialize_start();
+	
+	int match_count = list_count(&match_ids->ids);	
+	ipc_call_t answer;
+	aid_t req = async_send_2(phone, DEVMAN_ADD_CHILD_DEVICE, parent_handle, match_count, &answer);
+
+	ipcarg_t retval = async_data_write_start(phone, name, str_size(name));
+	if (retval != EOK) {
+		async_wait_for(req, NULL);
+		async_serialize_end();
+		return retval;
+	}
+	
+	devman_send_match_ids(phone, match_ids);
+	
+	async_wait_for(req, &retval);
+	
+	async_serialize_end();
+	
+	if (retval != EOK) {
+		if (handle != NULL) {
+			*handle = -1;
+		}
+		return retval;
+	}	
+	
+	if (handle != NULL)
+		*handle = (int) IPC_GET_ARG1(answer);	
+		
+	return retval;
+}
+
+int devman_add_device_to_class(device_handle_t dev_handle, const char *class_name)
+{
+	int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
+	
+	if (phone < 0)
+		return phone;
+	
+	async_serialize_start();
+	ipc_call_t answer;
+	aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS, dev_handle, &answer);
+	
+	ipcarg_t retval = async_data_write_start(phone, class_name, str_size(class_name));
+	if (retval != EOK) {
+		async_wait_for(req, NULL);
+		async_serialize_end();
+		return retval;
+	}
+	
+	async_wait_for(req, &retval);
+	async_serialize_end();
+	
+	return retval;	
+}
+
+void devman_hangup_phone(devman_interface_t iface)
+{
+	switch (iface) {
+	case DEVMAN_DRIVER:
+		if (devman_phone_driver >= 0) {
+			ipc_hangup(devman_phone_driver);
+			devman_phone_driver = -1;
+		}
+		break;
+	case DEVMAN_CLIENT:
+		if (devman_phone_client >= 0) {
+			ipc_hangup(devman_phone_client);
+			devman_phone_client = -1;
+		}
+		break;
+	default:
+		break;
+	}
+}
+
+int devman_device_connect(device_handle_t handle, unsigned int flags)
+{
+	int phone;
+	
+	if (flags & IPC_FLAG_BLOCKING) {
+		phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN,
+		    DEVMAN_CONNECT_TO_DEVICE, handle);
+	} else {
+		phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAN,
+		    DEVMAN_CONNECT_TO_DEVICE, handle);
+	}
+	
+	return phone;
+}
+
+int devman_parent_device_connect(device_handle_t handle, unsigned int flags)
+{
+	int phone;
+	
+	if (flags & IPC_FLAG_BLOCKING) {
+		phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN,
+		    DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
+	} else {
+		phone = ipc_connect_me_to(PHONE_NS, SERVICE_DEVMAN,
+		    DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
+	}
+	
+	return phone;
+}
+
+int devman_device_get_handle(const char *pathname, device_handle_t *handle, unsigned int flags)
+{
+	int phone = devman_get_phone(DEVMAN_CLIENT, flags);
+	
+	if (phone < 0)
+		return phone;
+	
+	async_serialize_start();
+	
+	ipc_call_t answer;
+	aid_t req = async_send_2(phone, DEVMAN_DEVICE_GET_HANDLE, flags, 0,
+	    &answer);
+	
+	ipcarg_t retval = async_data_write_start(phone, pathname, str_size(pathname));
+	if (retval != EOK) {
+		async_wait_for(req, NULL);
+		async_serialize_end();
+		return retval;
+	}
+	
+	async_wait_for(req, &retval);
+	
+	async_serialize_end();
+	
+	if (retval != EOK) {
+		if (handle != NULL)
+			*handle = (device_handle_t) -1;
+		return retval;
+	}
+	
+	if (handle != NULL)
+		*handle = (device_handle_t) IPC_GET_ARG1(answer);
+	
+	return retval;
+}
+
+
+/** @}
+ */
Index: uspace/lib/c/generic/task.c
===================================================================
--- uspace/lib/c/generic/task.c	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/generic/task.c	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -39,4 +39,5 @@
 #include <errno.h>
 #include <loader/loader.h>
+#include <stdarg.h>
 #include <str.h>
 #include <ipc/ns.h>
@@ -68,27 +69,25 @@
  *
  * This is really just a convenience wrapper over the more complicated
- * loader API.
- *
- * @param path Pathname of the binary to execute.
- * @param argv Command-line arguments.
- * @param err  If not NULL, the error value is stored here.
- *
- * @return ID of the newly created task or zero on error.
- *
- */
-task_id_t task_spawn(const char *path, const char *const args[], int *err)
-{
+ * loader API. Arguments are passed as a null-terminated array of strings.
+ *
+ * @param id 	If not NULL, the ID of the task is stored here on success.
+ * @param path	Pathname of the binary to execute.
+ * @param argv	Command-line arguments.
+ *
+ * @return	Zero on success or negative error code.
+ */
+int task_spawnv(task_id_t *id, const char *path, const char *const args[])
+{
+	loader_t *ldr;
+	task_id_t task_id;
+	int rc;
+
 	/* Connect to a program loader. */
-	loader_t *ldr = loader_connect();
-	if (ldr == NULL) {
-		if (err != NULL)
-			*err = EREFUSED;
-		
-		return 0;
-	}
+	ldr = loader_connect();
+	if (ldr == NULL)
+		return EREFUSED;
 	
 	/* Get task ID. */
-	task_id_t task_id;
-	int rc = loader_get_task_id(ldr, &task_id);
+	rc = loader_get_task_id(ldr, &task_id);
 	if (rc != EOK)
 		goto error;
@@ -149,8 +148,8 @@
 	free(ldr);
 	
-	if (err != NULL)
-		*err = EOK;
-	
-	return task_id;
+	if (id != NULL)
+		*id = task_id;
+	
+	return EOK;
 	
 error:
@@ -158,9 +157,54 @@
 	loader_abort(ldr);
 	free(ldr);
-	
-	if (err != NULL)
-		*err = rc;
-	
-	return 0;
+	return rc;
+}
+
+/** Create a new task by running an executable from the filesystem.
+ *
+ * This is really just a convenience wrapper over the more complicated
+ * loader API. Arguments are passed as a null-terminated list of arguments.
+ *
+ * @param id 	If not NULL, the ID of the task is stored here on success.
+ * @param path	Pathname of the binary to execute.
+ * @param ...	Command-line arguments.
+ *
+ * @return	Zero on success or negative error code.
+ */
+int task_spawnl(task_id_t *task_id, const char *path, ...)
+{
+	va_list ap;
+	int rc, cnt;
+	const char *arg;
+	const char **arglist;
+
+	/* Count the number of arguments. */
+	cnt = 0;
+	va_start(ap, path);
+	do {
+		arg = va_arg(ap, const char *);
+		cnt++;
+	} while (arg != NULL);
+	va_end(ap);
+
+	/* Allocate argument list. */
+	arglist = malloc(cnt * sizeof(const char *));
+	if (arglist == NULL)
+		return ENOMEM;
+
+	/* Fill in arguments. */
+	cnt = 0;
+	va_start(ap, path);
+	do {
+		arg = va_arg(ap, const char *);
+		arglist[cnt++] = arg;
+	} while (arg != NULL);
+	va_end(ap);
+
+	/* Spawn task. */
+	rc = task_spawnv(task_id, path, arglist);
+
+	/* Free argument list. */
+	free(arglist);
+	return rc;
 }
 
Index: uspace/lib/c/include/adt/measured_strings.h
===================================================================
--- uspace/lib/c/include/adt/measured_strings.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/include/adt/measured_strings.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -43,10 +43,10 @@
 
 /** Type definition of the character string with measured length.
- *  @see measured_string
+ * @see measured_string
  */
 typedef struct measured_string measured_string_t;
 
 /** Type definition of the character string with measured length pointer.
- *  @see measured_string
+ * @see measured_string
  */
 typedef measured_string_t *measured_string_ref;
@@ -59,5 +59,5 @@
 struct measured_string {
 	/** Character string data. */
-	char * value;
+	char *value;
 	/** Character string length. */
 	size_t length;
Index: uspace/lib/c/include/ddi.h
===================================================================
--- uspace/lib/c/include/ddi.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/include/ddi.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -42,4 +42,6 @@
 extern int iospace_enable(task_id_t, void *, unsigned long);
 extern int pio_enable(void *, size_t, void **);
+extern int interrupt_enable(int);
+extern int interrupt_disable(int);
 
 #endif
Index: uspace/lib/c/include/device/char.h
===================================================================
--- uspace/lib/c/include/device/char.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
+++ uspace/lib/c/include/device/char.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2010 Lenka Trochtova
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+ 
+ /** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+ 
+#ifndef LIBC_DEVICE_HW_RES_H_
+#define LIBC_DEVICE_HW_RES_H_
+
+typedef enum {
+	CHAR_READ_DEV = 0,
+	CHAR_WRITE_DEV	
+} hw_res_funcs_t;
+
+int read_dev(int dev_phone, void *buf, size_t len);
+int write_dev(int dev_phone, void *buf, size_t len);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/c/include/device/hw_res.h
===================================================================
--- uspace/lib/c/include/device/hw_res.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
+++ uspace/lib/c/include/device/hw_res.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -0,0 +1,105 @@
+/*
+ * Copyright (c) 2010 Lenka Trochtova
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+ 
+ /** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+ 
+#ifndef LIBC_DEVICE_HW_RES_H_
+#define LIBC_DEVICE_HW_RES_H_
+
+#include <ipc/dev_iface.h>
+#include <bool.h>
+
+// HW resource provider interface
+
+typedef enum {
+	GET_RESOURCE_LIST = 0,
+	ENABLE_INTERRUPT	
+} hw_res_funcs_t;
+
+/** HW resource types. */
+typedef enum {
+	INTERRUPT,
+	IO_RANGE, 
+	MEM_RANGE
+} hw_res_type_t;
+
+typedef enum {
+	LITTLE_ENDIAN = 0,
+	BIG_ENDIAN
+} endianness_t;
+
+
+/** HW resource (e.g. interrupt, memory register, i/o register etc.). */
+typedef struct hw_resource {
+	hw_res_type_t type;
+	union {
+		struct {
+			uint64_t address;
+			endianness_t endianness;			
+			size_t size;			
+		} mem_range;
+		struct {
+			uint64_t address;
+			endianness_t endianness;			
+			size_t size;			
+		} io_range;
+		struct {
+			int irq;			
+		} interrupt;		
+	} res;	
+} hw_resource_t;
+
+typedef struct hw_resource_list {
+	size_t count;
+	hw_resource_t *resources;	
+} hw_resource_list_t;
+
+static inline void clean_hw_resource_list(hw_resource_list_t *hw_res)
+{
+	if(NULL != hw_res->resources) {
+		free(hw_res->resources);
+		hw_res->resources = NULL;
+	}
+	hw_res->count = 0;	
+}
+
+
+
+bool get_hw_resources(int dev_phone, hw_resource_list_t *hw_resources);
+
+bool enable_interrupt(int dev_phone);
+
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/c/include/devman.h
===================================================================
--- uspace/lib/c/include/devman.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
+++ uspace/lib/c/include/devman.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2009 Jiri Svoboda
+ * Copyright (c) 2010 Lenka Trochtova 
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libc
+ * @{
+ */
+/** @file
+ */
+
+#ifndef LIBC_DEVMAN_H_
+#define LIBC_DEVMAN_H_
+
+#include <ipc/devman.h>
+#include <async.h>
+#include <bool.h>
+
+
+int devman_get_phone(devman_interface_t, unsigned int);
+void devman_hangup_phone(devman_interface_t iface);
+
+int devman_driver_register(const char *, async_client_conn_t);
+int devman_child_device_register(const char *, match_id_list_t *, device_handle_t, device_handle_t *);
+
+int devman_device_connect(device_handle_t handle, unsigned int flags);
+int devman_parent_device_connect(device_handle_t handle, unsigned int flags);
+
+int devman_device_get_handle(const char *pathname, device_handle_t *handle, unsigned int flags);
+
+int devman_add_device_to_class(device_handle_t dev_handle, const char *class_name);
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/c/include/ipc/dev_iface.h
===================================================================
--- uspace/lib/c/include/ipc/dev_iface.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
+++ uspace/lib/c/include/ipc/dev_iface.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2010 Lenka Trochtova
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LIBC_IPC_DEV_IFACE_H_
+#define LIBC_IPC_DEV_IFACE_H_
+
+#include <ipc/ipc.h>
+#include <malloc.h>
+#include <unistd.h>
+#include <libarch/types.h>
+
+typedef enum {	
+	HW_RES_DEV_IFACE = 0,	
+	CHAR_DEV_IFACE,
+	// TODO add more interfaces
+	DEV_IFACE_MAX
+} dev_inferface_idx_t;
+
+#define DEV_IFACE_ID(idx)	((idx) + IPC_FIRST_USER_METHOD)
+#define DEV_IFACE_IDX(id)	((id) - IPC_FIRST_USER_METHOD)
+
+#define DEV_IFACE_COUNT			DEV_IFACE_MAX
+#define DEV_FIRST_CUSTOM_METHOD_IDX	DEV_IFACE_MAX
+#define DEV_FIRST_CUSTOM_METHOD \
+	DEV_IFACE_ID(DEV_FIRST_CUSTOM_METHOD_IDX)
+
+
+#endif
Index: uspace/lib/c/include/ipc/devman.h
===================================================================
--- uspace/lib/c/include/ipc/devman.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
+++ uspace/lib/c/include/ipc/devman.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2010 Lenka Trochtova
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup devman
+ * @{
+ */
+ 
+#ifndef LIBC_IPC_DEVMAN_H_
+#define LIBC_IPC_DEVMAN_H_
+
+#include <adt/list.h>
+#include <ipc/ipc.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <str.h>
+
+#define DEVMAN_NAME_MAXLEN 256
+
+typedef ipcarg_t device_handle_t;
+
+/** Ids of device models used for device-to-driver matching.
+ */
+typedef struct match_id {
+	/** Pointers to next and previous ids.
+	 */
+	link_t link;
+	/** Id of device model.
+	 */
+	const char *id;
+	/** Relevancy of device-to-driver match.
+	 * The higher is the product of scores specified for the device by the bus driver and by the leaf driver,
+	 * the more suitable is the leaf driver for handling the device.
+	 */
+	unsigned int score;
+} match_id_t;
+
+/** List of ids for matching devices to drivers sorted
+ * according to match scores in descending order.
+ */
+typedef struct match_id_list {
+	link_t ids;
+} match_id_list_t;
+
+
+static inline match_id_t * create_match_id()
+{
+	match_id_t *id = malloc(sizeof(match_id_t));
+	memset(id, 0, sizeof(match_id_t));
+	return id;
+}
+
+static inline void delete_match_id(match_id_t *id)
+{
+	if (id) {
+		if (NULL != id->id) {
+			free(id->id);
+		}
+		free(id);
+	}
+}
+
+static inline void add_match_id(match_id_list_t *ids, match_id_t *id) 
+{
+	match_id_t *mid = NULL;
+	link_t *link = ids->ids.next;	
+	
+	while (link != &ids->ids) {
+		mid = list_get_instance(link, match_id_t,link);
+		if (mid->score < id->score) {
+			break;
+		}	
+		link = link->next;
+	}
+	
+	list_insert_before(&id->link, link);	
+}
+
+static inline void init_match_ids(match_id_list_t *id_list)
+{
+	list_initialize(&id_list->ids);
+}
+
+static inline void clean_match_ids(match_id_list_t *ids)
+{
+	link_t *link = NULL;
+	match_id_t *id;
+	
+	while(!list_empty(&ids->ids)) {
+		link = ids->ids.next;
+		list_remove(link);		
+		id = list_get_instance(link, match_id_t, link);
+		delete_match_id(id);		
+	}	
+}
+
+typedef enum {
+	DEVMAN_DRIVER = 1,
+	DEVMAN_CLIENT,
+	DEVMAN_CONNECT_TO_DEVICE,
+	DEVMAN_CONNECT_TO_PARENTS_DEVICE
+} devman_interface_t;
+
+typedef enum {
+	DEVMAN_DRIVER_REGISTER = IPC_FIRST_USER_METHOD,
+	DEVMAN_ADD_CHILD_DEVICE,
+	DEVMAN_ADD_MATCH_ID,
+	DEVMAN_ADD_DEVICE_TO_CLASS
+
+} driver_to_devman_t;
+
+typedef enum {
+	DRIVER_ADD_DEVICE = IPC_FIRST_USER_METHOD
+
+} devman_to_driver_t;
+
+typedef enum {
+	DEVMAN_DEVICE_GET_HANDLE = IPC_FIRST_USER_METHOD
+} client_to_devman_t;
+
+#endif
+
+/** @}
+ */
Index: uspace/lib/c/include/ipc/driver.h
===================================================================
--- uspace/lib/c/include/ipc/driver.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
+++ uspace/lib/c/include/ipc/driver.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -0,0 +1,50 @@
+/*
+ * Copyright (c) 2010 Lenka Trochtova 
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup libdrv
+ * @{
+ */
+/** @file
+ */
+
+#ifndef IPC_DRIVER_H_
+#define IPC_DRIVER_H_
+
+typedef enum {
+	DRIVER_DEVMAN = 1,
+	DRIVER_CLIENT,
+	DRIVER_DRIVER
+} driver_interface_t;
+
+
+#endif
+
+
+/**
+ * @}
+ */
Index: uspace/lib/c/include/ipc/serial.h
===================================================================
--- uspace/lib/c/include/ipc/serial.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
+++ uspace/lib/c/include/ipc/serial.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -0,0 +1,14 @@
+#ifndef LIBC_FB_H_
+#define LIBC_FB_H_
+
+#include <ipc/ipc.h>
+
+typedef enum {
+	SERIAL_PUTCHAR = IPC_FIRST_USER_METHOD,
+	SERIAL_GETCHAR,
+	SERIAL_READ,
+	SERIAL_WRITE,
+} serial_request_t;
+
+
+#endif
Index: uspace/lib/c/include/ipc/serial_ctl.h
===================================================================
--- uspace/lib/c/include/ipc/serial_ctl.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
+++ uspace/lib/c/include/ipc/serial_ctl.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2010 Lenka Trochtova
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef LIBC_IPC_SERIAL_CTL_H_
+#define LIBC_IPC_SERIAL_CTL_H_
+
+#include <ipc/dev_iface.h>
+
+/** ipc methods for getting/setting serial communication properties
+ * 	1st ipc arg: baud rate
+ * 	2nd ipc arg: parity
+ *	3rd ipc arg: number of bits in one word
+ *	4th ipc arg: number of stop bits
+ */
+typedef enum {	
+	SERIAL_GET_COM_PROPS = DEV_FIRST_CUSTOM_METHOD,
+	SERIAL_SET_COM_PROPS
+} serial_ctl_t;
+
+typedef enum {
+	SERIAL_NO_PARITY = 0,
+	SERIAL_ODD_PARITY = 1,
+	SERIAL_EVEN_PARITY = 3,
+	SERIAL_MARK_PARITY = 5,
+	SERIAL_SPACE_PARITY = 7	
+} serial_parity_t;
+
+#endif
Index: uspace/lib/c/include/ipc/services.h
===================================================================
--- uspace/lib/c/include/ipc/services.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/include/ipc/services.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -39,5 +39,6 @@
 
 typedef enum {
-	SERVICE_LOAD = 1,
+	SERVICE_NONE = 0,
+	SERVICE_LOAD,
 	SERVICE_PCI,
 	SERVICE_VIDEO,
@@ -45,4 +46,5 @@
 	SERVICE_VFS,
 	SERVICE_DEVMAP,
+	SERVICE_DEVMAN,
 	SERVICE_FHC,
 	SERVICE_OBIO,
Index: uspace/lib/c/include/net/icmp_codes.h
===================================================================
--- uspace/lib/c/include/net/icmp_codes.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/include/net/icmp_codes.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -42,4 +42,6 @@
 #define LIBC_ICMP_CODES_H_
 
+#include <sys/types.h>
+
 /** ICMP type type definition. */
 typedef uint8_t icmp_type_t;
Index: uspace/lib/c/include/task.h
===================================================================
--- uspace/lib/c/include/task.h	(revision 9414abc19106996bac61d12354e75953aa14bf29)
+++ uspace/lib/c/include/task.h	(revision 5d0f1bc98f63dba53e1c3f9b28ec5a020e3bbe81)
@@ -48,4 +48,7 @@
 extern int task_set_name(const char *);
 extern task_id_t task_spawn(const char *, const char *const[], int *);
+extern int task_spawnv(task_id_t *, const char *path, const char *const []);
+extern int task_spawnl(task_id_t *, const char *path, ...);
+
 extern int task_wait(task_id_t id, task_exit_t *, int *);
 extern int task_retval(int);