Index: abi/include/abi/cap.h
===================================================================
--- abi/include/abi/cap.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ abi/include/abi/cap.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -38,5 +38,12 @@
 #define CAP_NIL		0
 
-typedef int cap_handle_t;
+#define CAP_HANDLE_VALID(handle)	((handle) != CAP_NIL)
+#define CAP_HANDLE_RAW(handle)		((intptr_t) (handle))
+
+typedef void *cap_handle_t;
+
+typedef struct {} *cap_call_handle_t;
+typedef struct {} *cap_phone_handle_t;
+typedef struct {} *cap_irq_handle_t;
 
 #endif
Index: abi/include/abi/ipc/methods.h
===================================================================
--- abi/include/abi/ipc/methods.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ abi/include/abi/ipc/methods.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -39,5 +39,5 @@
 
 /* Well known phone descriptors */
-#define PHONE_NS  (CAP_NIL + 1)
+#define PHONE_NS  ((cap_phone_handle_t) (CAP_NIL + 1))
 
 /** Kernel IPC interfaces
Index: abi/include/abi/mm/as.h
===================================================================
--- abi/include/abi/mm/as.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ abi/include/abi/mm/as.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -36,4 +36,6 @@
 #define ABI_AS_H_
 
+#include <abi/cap.h>
+
 /** Address space area flags. */
 #define AS_AREA_READ         0x01
@@ -62,5 +64,5 @@
 
 typedef struct {
-	int pager;
+	cap_phone_handle_t pager;
 	sysarg_t id1;
 	sysarg_t id2;
Index: kernel/generic/include/ipc/ipc.h
===================================================================
--- kernel/generic/include/ipc/ipc.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/include/ipc/ipc.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -116,5 +116,5 @@
 	sysarg_t label;
 	/** Capability handle */
-	cap_handle_t cap_handle;
+	cap_call_handle_t cap_handle;
 } ipc_data_t;
 
Index: kernel/generic/include/ipc/ipcrsc.h
===================================================================
--- kernel/generic/include/ipc/ipcrsc.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/include/ipc/ipcrsc.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -40,6 +40,6 @@
 #include <cap/cap.h>
 
-extern errno_t phone_alloc(task_t *, bool, cap_handle_t *, kobject_t **);
-extern void phone_dealloc(cap_handle_t);
+extern errno_t phone_alloc(task_t *, bool, cap_phone_handle_t *, kobject_t **);
+extern void phone_dealloc(cap_phone_handle_t);
 
 #endif
Index: kernel/generic/include/ipc/irq.h
===================================================================
--- kernel/generic/include/ipc/irq.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/include/ipc/irq.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -52,6 +52,6 @@
 
 extern errno_t ipc_irq_subscribe(answerbox_t *, inr_t, sysarg_t, irq_code_t *,
-    cap_handle_t *);
-extern errno_t ipc_irq_unsubscribe(answerbox_t *, int);
+    cap_irq_handle_t *);
+extern errno_t ipc_irq_unsubscribe(answerbox_t *, cap_irq_handle_t);
 
 /*
Index: kernel/generic/include/ipc/kbox.h
===================================================================
--- kernel/generic/include/ipc/kbox.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/include/ipc/kbox.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -50,5 +50,5 @@
 } kbox_t;
 
-extern errno_t ipc_connect_kbox(task_id_t, cap_handle_t *);
+extern errno_t ipc_connect_kbox(task_id_t, cap_phone_handle_t *);
 extern void ipc_kbox_cleanup(void);
 
Index: kernel/generic/include/ipc/sysipc.h
===================================================================
--- kernel/generic/include/ipc/sysipc.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/include/ipc/sysipc.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -40,24 +40,26 @@
 #include <typedefs.h>
 
-extern errno_t ipc_req_internal(int, ipc_data_t *, sysarg_t);
+extern errno_t ipc_req_internal(cap_phone_handle_t, ipc_data_t *, sysarg_t);
 
-extern sys_errno_t sys_ipc_call_async_fast(sysarg_t, sysarg_t, sysarg_t,
+extern sys_errno_t sys_ipc_call_async_fast(cap_phone_handle_t, sysarg_t,
+    sysarg_t, sysarg_t, sysarg_t, sysarg_t);
+extern sys_errno_t sys_ipc_call_async_slow(cap_phone_handle_t, ipc_data_t *,
+    sysarg_t);
+extern sys_errno_t sys_ipc_answer_fast(cap_call_handle_t, sysarg_t, sysarg_t,
     sysarg_t, sysarg_t, sysarg_t);
-extern sys_errno_t sys_ipc_call_async_slow(sysarg_t, ipc_data_t *, sysarg_t);
-extern sys_errno_t sys_ipc_answer_fast(sysarg_t, sysarg_t, sysarg_t, sysarg_t,
-    sysarg_t, sysarg_t);
-extern sys_errno_t sys_ipc_answer_slow(sysarg_t, ipc_data_t *);
+extern sys_errno_t sys_ipc_answer_slow(cap_call_handle_t, ipc_data_t *);
 extern sys_errno_t sys_ipc_wait_for_call(ipc_data_t *, uint32_t, unsigned int);
 extern sys_errno_t sys_ipc_poke(void);
-extern sys_errno_t sys_ipc_forward_fast(sysarg_t, sysarg_t, sysarg_t, sysarg_t,
-    sysarg_t, unsigned int);
-extern sys_errno_t sys_ipc_forward_slow(sysarg_t, sysarg_t, ipc_data_t *,
-    unsigned int);
-extern sys_errno_t sys_ipc_hangup(sysarg_t);
+extern sys_errno_t sys_ipc_forward_fast(cap_call_handle_t, cap_phone_handle_t,
+    sysarg_t, sysarg_t, sysarg_t, unsigned int);
+extern sys_errno_t sys_ipc_forward_slow(cap_call_handle_t, cap_phone_handle_t,
+    ipc_data_t *, unsigned int);
+extern sys_errno_t sys_ipc_hangup(cap_phone_handle_t);
 
-extern sys_errno_t sys_ipc_irq_subscribe(inr_t, sysarg_t, irq_code_t *, cap_handle_t *);
-extern sys_errno_t sys_ipc_irq_unsubscribe(sysarg_t);
+extern sys_errno_t sys_ipc_irq_subscribe(inr_t, sysarg_t, irq_code_t *,
+    cap_irq_handle_t *);
+extern sys_errno_t sys_ipc_irq_unsubscribe(cap_irq_handle_t);
 
-extern sys_errno_t sys_ipc_connect_kbox(task_id_t *, cap_handle_t *);
+extern sys_errno_t sys_ipc_connect_kbox(task_id_t *, cap_phone_handle_t *);
 
 #endif
Index: kernel/generic/src/cap/cap.c
===================================================================
--- kernel/generic/src/cap/cap.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/src/cap/cap.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -92,5 +92,5 @@
 {
 	cap_t *cap = hash_table_get_inst(item, cap_t, caps_link);
-	return hash_mix(cap->handle);
+	return hash_mix(CAP_HANDLE_RAW(cap->handle));
 }
 
@@ -98,5 +98,5 @@
 {
 	cap_handle_t *handle = (cap_handle_t *) key;
-	return hash_mix(*handle);
+	return hash_mix(CAP_HANDLE_RAW(*handle));
 }
 
@@ -224,5 +224,6 @@
 	assert(mutex_locked(&task->cap_info->lock));
 
-	if ((handle < CAPS_START) || (handle > CAPS_LAST))
+	if ((CAP_HANDLE_RAW(handle) < CAPS_START) ||
+	    (CAP_HANDLE_RAW(handle) > CAPS_LAST))
 		return NULL;
 	ht_link_t *link = hash_table_find(&task->cap_info->caps, &handle);
@@ -329,6 +330,6 @@
 void cap_free(task_t *task, cap_handle_t handle)
 {
-	assert(handle >= CAPS_START);
-	assert(handle <= CAPS_LAST);
+	assert(CAP_HANDLE_RAW(handle) >= CAPS_START);
+	assert(CAP_HANDLE_RAW(handle) <= CAPS_LAST);
 
 	mutex_lock(&task->cap_info->lock);
@@ -338,5 +339,5 @@
 
 	hash_table_remove_item(&task->cap_info->caps, &cap->caps_link);
-	ra_free(task->cap_info->handles, handle, 1);
+	ra_free(task->cap_info->handles, CAP_HANDLE_RAW(handle), 1);
 	slab_free(cap_cache, cap);
 	mutex_unlock(&task->cap_info->lock);
Index: kernel/generic/src/ipc/ipc.c
===================================================================
--- kernel/generic/src/ipc/ipc.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/src/ipc/ipc.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -910,5 +910,5 @@
 	mutex_lock(&phone->lock);
 	if (phone->state != IPC_PHONE_FREE) {
-		printf("%-11d %7" PRIun " ", cap->handle,
+		printf("%-11d %7" PRIun " ", (int) CAP_HANDLE_RAW(cap->handle),
 		    atomic_get(&phone->active_calls));
 
Index: kernel/generic/src/ipc/ipcrsc.c
===================================================================
--- kernel/generic/src/ipc/ipcrsc.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/src/ipc/ipcrsc.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -157,5 +157,5 @@
  * @return  An error code if a new capability cannot be allocated.
  */
-errno_t phone_alloc(task_t *task, bool publish, cap_handle_t *phandle,
+errno_t phone_alloc(task_t *task, bool publish, cap_phone_handle_t *phandle,
     kobject_t **kobject)
 {
@@ -199,5 +199,5 @@
  *
  */
-void phone_dealloc(cap_handle_t handle)
+void phone_dealloc(cap_phone_handle_t handle)
 {
 	kobject_t *kobj = cap_unpublish(TASK, handle, KOBJECT_TYPE_PHONE);
Index: kernel/generic/src/ipc/irq.c
===================================================================
--- kernel/generic/src/ipc/irq.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/src/ipc/irq.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -314,5 +314,5 @@
  */
 errno_t ipc_irq_subscribe(answerbox_t *box, inr_t inr, sysarg_t imethod,
-    irq_code_t *ucode, cap_handle_t *uspace_handle)
+    irq_code_t *ucode, cap_irq_handle_t *uspace_handle)
 {
 	if ((inr < 0) || (inr > last_inr))
@@ -390,5 +390,5 @@
  *
  */
-errno_t ipc_irq_unsubscribe(answerbox_t *box, int handle)
+errno_t ipc_irq_unsubscribe(answerbox_t *box, cap_irq_handle_t handle)
 {
 	kobject_t *kobj = cap_unpublish(TASK, handle, KOBJECT_TYPE_IRQ);
Index: kernel/generic/src/ipc/kbox.c
===================================================================
--- kernel/generic/src/ipc/kbox.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/src/ipc/kbox.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -210,5 +210,5 @@
  *
  */
-errno_t ipc_connect_kbox(task_id_t taskid, cap_handle_t *out_phone)
+errno_t ipc_connect_kbox(task_id_t taskid, cap_phone_handle_t *out_phone)
 {
 	irq_spinlock_lock(&tasks_lock, true);
@@ -252,5 +252,5 @@
 
 	/* Allocate a new phone. */
-	cap_handle_t phone_handle;
+	cap_phone_handle_t phone_handle;
 	errno_t rc = phone_alloc(TASK, true, &phone_handle, NULL);
 	if (rc != EOK) {
Index: kernel/generic/src/ipc/ops/conctmeto.c
===================================================================
--- kernel/generic/src/ipc/ops/conctmeto.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/src/ipc/ops/conctmeto.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -46,5 +46,5 @@
 	 * That will be done once the phone is connected.
 	 */
-	cap_handle_t phone_handle;
+	cap_phone_handle_t phone_handle;
 	kobject_t *phone_obj;
 	errno_t rc = phone_alloc(TASK, false, &phone_handle, &phone_obj);
@@ -58,5 +58,5 @@
 
 	/* Remember the handle */
-	call->priv = phone_handle;
+	call->priv = CAP_HANDLE_RAW(phone_handle);
 
 	return EOK;
@@ -65,7 +65,7 @@
 static errno_t request_forget(call_t *call)
 {
-	cap_handle_t phone_handle = (cap_handle_t) call->priv;
+	cap_phone_handle_t phone_handle = (cap_handle_t) call->priv;
 
-	if (phone_handle < 0)
+	if (CAP_HANDLE_RAW(phone_handle) < 0)
 		return EOK;
 
@@ -103,9 +103,9 @@
 static errno_t answer_process(call_t *answer)
 {
-	cap_handle_t phone_handle = (cap_handle_t) answer->priv;
+	cap_phone_handle_t phone_handle = (cap_handle_t) answer->priv;
 	phone_t *phone = (phone_t *) IPC_GET_ARG5(answer->data);
 
 	if (IPC_GET_RETVAL(answer->data)) {
-		if (phone_handle >= 0) {
+		if (CAP_HANDLE_RAW(phone_handle) >= 0) {
 			/*
 			 * Cleanup the unpublished capability and drop
@@ -123,5 +123,5 @@
 		cap_publish(TASK, phone_handle, phone->kobject);
 
-		IPC_SET_ARG5(answer->data, phone_handle);
+		IPC_SET_ARG5(answer->data, CAP_HANDLE_RAW(phone_handle));
 	}
 
Index: kernel/generic/src/ipc/ops/concttome.c
===================================================================
--- kernel/generic/src/ipc/ops/concttome.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/src/ipc/ops/concttome.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -42,9 +42,10 @@
 static int request_process(call_t *call, answerbox_t *box)
 {
-	cap_handle_t phone_handle;
+	cap_phone_handle_t phone_handle;
 	kobject_t *phone_obj;
 	errno_t rc = phone_alloc(TASK, false, &phone_handle, &phone_obj);
 	call->priv = (sysarg_t) phone_obj;
-	IPC_SET_ARG5(call->data, (rc == EOK) ? phone_handle : -1);
+	IPC_SET_ARG5(call->data,
+	    (rc == EOK) ? CAP_HANDLE_RAW(phone_handle) : CAP_NIL);
 	return 0;
 }
@@ -52,8 +53,8 @@
 static errno_t answer_cleanup(call_t *answer, ipc_data_t *olddata)
 {
-	cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
+	cap_phone_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
 	kobject_t *phone_obj = (kobject_t *) answer->priv;
 
-	if (phone_handle >= 0) {
+	if (CAP_HANDLE_VALID(phone_handle)) {
 		kobject_put(phone_obj);
 		cap_free(TASK, phone_handle);
@@ -65,5 +66,5 @@
 static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
-	cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
+	cap_phone_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
 	kobject_t *phone_obj = (kobject_t *) answer->priv;
 
@@ -71,5 +72,5 @@
 		/* The connection was not accepted */
 		answer_cleanup(answer, olddata);
-	} else if (phone_handle >= 0) {
+	} else if (CAP_HANDLE_VALID(phone_handle)) {
 		/*
 		 * The connection was accepted
Index: kernel/generic/src/ipc/ops/stchngath.c
===================================================================
--- kernel/generic/src/ipc/ops/stchngath.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/src/ipc/ops/stchngath.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -45,6 +45,6 @@
 	task_t *other_task_s;
 
-	kobject_t *sender_obj = kobject_get(TASK, IPC_GET_ARG5(call->data),
-	    KOBJECT_TYPE_PHONE);
+	kobject_t *sender_obj = kobject_get(TASK,
+	    (cap_handle_t) IPC_GET_ARG5(call->data), KOBJECT_TYPE_PHONE);
 	if (!sender_obj)
 		return ENOENT;
@@ -78,5 +78,6 @@
 
 		kobject_t *recipient_obj = kobject_get(TASK,
-		    IPC_GET_ARG1(answer->data), KOBJECT_TYPE_PHONE);
+		    (cap_handle_t) IPC_GET_ARG1(answer->data),
+		    KOBJECT_TYPE_PHONE);
 		if (!recipient_obj) {
 			IPC_SET_RETVAL(answer->data, ENOENT);
Index: kernel/generic/src/ipc/sysipc.c
===================================================================
--- kernel/generic/src/ipc/sysipc.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/src/ipc/sysipc.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -271,5 +271,6 @@
  *
  */
-errno_t ipc_req_internal(cap_handle_t handle, ipc_data_t *data, sysarg_t priv)
+errno_t
+ipc_req_internal(cap_phone_handle_t handle, ipc_data_t *data, sysarg_t priv)
 {
 	kobject_t *kobj = kobject_get(TASK, handle, KOBJECT_TYPE_PHONE);
@@ -362,5 +363,5 @@
  *
  */
-sys_errno_t sys_ipc_call_async_fast(sysarg_t handle, sysarg_t imethod,
+sys_errno_t sys_ipc_call_async_fast(cap_phone_handle_t handle, sysarg_t imethod,
     sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t label)
 {
@@ -409,5 +410,5 @@
  *
  */
-sys_errno_t sys_ipc_call_async_slow(sysarg_t handle, ipc_data_t *data,
+sys_errno_t sys_ipc_call_async_slow(cap_phone_handle_t handle, ipc_data_t *data,
     sysarg_t label)
 {
@@ -466,7 +467,7 @@
  *
  */
-static sys_errno_t sys_ipc_forward_common(sysarg_t chandle, sysarg_t phandle,
-    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
-    sysarg_t arg4, sysarg_t arg5, unsigned int mode, bool slow)
+static sys_errno_t sys_ipc_forward_common(cap_call_handle_t chandle,
+    cap_phone_handle_t phandle, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, unsigned int mode, bool slow)
 {
 	kobject_t *ckobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
@@ -506,5 +507,6 @@
 		if (method_is_system(IPC_GET_IMETHOD(call->data))) {
 			if (IPC_GET_IMETHOD(call->data) == IPC_M_CONNECT_TO_ME)
-				phone_dealloc(IPC_GET_ARG5(call->data));
+				phone_dealloc((cap_phone_handle_t)
+				    IPC_GET_ARG5(call->data));
 
 			IPC_SET_ARG1(call->data, imethod);
@@ -577,6 +579,7 @@
  *
  */
-sys_errno_t sys_ipc_forward_fast(sysarg_t chandle, sysarg_t phandle,
-    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
+sys_errno_t sys_ipc_forward_fast(cap_call_handle_t chandle,
+    cap_phone_handle_t phandle, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
+    unsigned int mode)
 {
 	return sys_ipc_forward_common(chandle, phandle, imethod, arg1, arg2, 0,
@@ -601,6 +604,6 @@
  *
  */
-sys_errno_t sys_ipc_forward_slow(sysarg_t chandle, sysarg_t phandle,
-    ipc_data_t *data, unsigned int mode)
+sys_errno_t sys_ipc_forward_slow(cap_call_handle_t chandle,
+    cap_phone_handle_t phandle, ipc_data_t *data, unsigned int mode)
 {
 	ipc_data_t newdata;
@@ -631,6 +634,6 @@
  *
  */
-sys_errno_t sys_ipc_answer_fast(sysarg_t chandle, sysarg_t retval, sysarg_t arg1,
-    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
+sys_errno_t sys_ipc_answer_fast(cap_call_handle_t chandle, sysarg_t retval,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
 {
 	kobject_t *kobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
@@ -678,5 +681,5 @@
  *
  */
-sys_errno_t sys_ipc_answer_slow(sysarg_t chandle, ipc_data_t *data)
+sys_errno_t sys_ipc_answer_slow(cap_call_handle_t chandle, ipc_data_t *data)
 {
 	kobject_t *kobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
@@ -722,5 +725,5 @@
  *
  */
-sys_errno_t sys_ipc_hangup(sysarg_t handle)
+sys_errno_t sys_ipc_hangup(cap_phone_handle_t handle)
 {
 	kobject_t *kobj = cap_unpublish(TASK, handle, KOBJECT_TYPE_PHONE);
@@ -800,5 +803,5 @@
 		goto restart;
 
-	cap_handle_t handle;
+	cap_handle_t handle = CAP_NIL;
 	errno_t rc = cap_alloc(TASK, &handle);
 	if (rc != EOK) {
@@ -821,5 +824,5 @@
 
 error:
-	if (handle >= 0)
+	if (CAP_HANDLE_VALID(handle))
 		cap_free(TASK, handle);
 
@@ -861,5 +864,5 @@
  * @param ucode   Uspace pointer to the top-half pseudocode.
  *
- * @param[out] uspace_handle  Uspace pointer to IRQ kernel object capability
+ * @param[out] uspace_handle  Uspace pointer to IRQ capability handle
  *
  * @return EPERM
@@ -867,6 +870,6 @@
  *
  */
-sys_errno_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod, irq_code_t *ucode,
-	cap_handle_t *uspace_handle)
+sys_errno_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod,
+    irq_code_t *ucode, cap_irq_handle_t *uspace_handle)
 {
 	if (!(perm_get(TASK) & PERM_IRQ_REG))
@@ -878,16 +881,15 @@
 /** Disconnect an IRQ handler from a task.
  *
- * @param inr   IRQ number.
- * @param devno Device number.
+ * @param handle  IRQ capability handle.
  *
  * @return Zero on success or EPERM on error.
  *
  */
-sys_errno_t sys_ipc_irq_unsubscribe(sysarg_t cap)
+sys_errno_t sys_ipc_irq_unsubscribe(cap_irq_handle_t handle)
 {
 	if (!(perm_get(TASK) & PERM_IRQ_REG))
 		return EPERM;
 
-	ipc_irq_unsubscribe(&TASK->answerbox, cap);
+	ipc_irq_unsubscribe(&TASK->answerbox, handle);
 
 	return 0;
@@ -899,9 +901,10 @@
  *
  */
-sys_errno_t sys_ipc_connect_kbox(task_id_t *uspace_taskid, cap_handle_t *uspace_phone)
+sys_errno_t sys_ipc_connect_kbox(task_id_t *uspace_taskid,
+    cap_phone_handle_t *uspace_phone)
 {
 #ifdef CONFIG_UDEBUG
 	task_id_t taskid;
-	cap_handle_t phone;
+	cap_phone_handle_t phone;
 
 	errno_t rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(task_id_t));
Index: kernel/generic/src/mm/backend_user.c
===================================================================
--- kernel/generic/src/mm/backend_user.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/src/mm/backend_user.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -131,5 +131,5 @@
 		log(LF_USPACE, LVL_FATAL,
 		    "Page-in request for page %#" PRIxPTR
-		    " at pager %d failed with error %s.",
+		    " at pager %p failed with error %s.",
 		    upage, pager_info->pager, str_error_name(rc));
 		return AS_PF_FAULT;
Index: kernel/generic/src/proc/task.c
===================================================================
--- kernel/generic/src/proc/task.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ kernel/generic/src/proc/task.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -245,5 +245,5 @@
 	if ((ipc_box_0) &&
 	    (container_check(ipc_box_0->task->container, task->container))) {
-		cap_handle_t phone_handle;
+		cap_phone_handle_t phone_handle;
 		errno_t rc = phone_alloc(task, true, &phone_handle, NULL);
 		if (rc != EOK) {
Index: uspace/app/trace/ipcp.c
===================================================================
--- uspace/app/trace/ipcp.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/app/trace/ipcp.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -46,9 +46,9 @@
 
 typedef struct {
-	sysarg_t phone_hash;
+	cap_phone_handle_t phone_handle;
 	ipc_call_t question;
 	oper_t *oper;
 
-	ipc_callid_t call_hash;
+	cap_call_handle_t call_handle;
 
 	ht_link_t link;
@@ -75,6 +75,6 @@
 static size_t pending_call_key_hash(void *key)
 {
-	ipc_callid_t *call_id = (ipc_callid_t *)key;
-	return *call_id;
+	cap_call_handle_t *chandle = (cap_call_handle_t *) key;
+	return CAP_HANDLE_RAW(*chandle);
 }
 
@@ -82,13 +82,13 @@
 {
 	pending_call_t *hs = hash_table_get_inst(item, pending_call_t, link);
-	return hs->call_hash;
+	return CAP_HANDLE_RAW(hs->call_handle);
 }
 
 static bool pending_call_key_equal(void *key, const ht_link_t *item)
 {
-	ipc_callid_t *call_id = (ipc_callid_t *)key;
+	cap_call_handle_t *chandle = (cap_call_handle_t *) key;
 	pending_call_t *hs = hash_table_get_inst(item, pending_call_t, link);
 
-	return *call_id == hs->call_hash;
+	return *chandle == hs->call_handle;
 }
 
@@ -102,17 +102,20 @@
 
 
-void ipcp_connection_set(int phone, int server, proto_t *proto)
-{
-	if (phone <0 || phone >= MAX_PHONE) return;
-	connections[phone].server = server;
-	connections[phone].proto = proto;
-	have_conn[phone] = 1;
-}
-
-void ipcp_connection_clear(int phone)
-{
-	have_conn[phone] = 0;
-	connections[phone].server = 0;
-	connections[phone].proto = NULL;
+void ipcp_connection_set(cap_phone_handle_t phone, int server, proto_t *proto)
+{
+	// XXX: there is no longer a limit on the number of phones as phones are
+	// now handled using capabilities
+	if (CAP_HANDLE_RAW(phone) < 0 || CAP_HANDLE_RAW(phone) >= MAX_PHONE)
+	    return;
+	connections[CAP_HANDLE_RAW(phone)].server = server;
+	connections[CAP_HANDLE_RAW(phone)].proto = proto;
+	have_conn[CAP_HANDLE_RAW(phone)] = 1;
+}
+
+void ipcp_connection_clear(cap_phone_handle_t phone)
+{
+	have_conn[CAP_HANDLE_RAW(phone)] = 0;
+	connections[CAP_HANDLE_RAW(phone)].server = 0;
+	connections[CAP_HANDLE_RAW(phone)].proto = NULL;
 }
 
@@ -174,5 +177,6 @@
 }
 
-void ipcp_call_out(int phone, ipc_call_t *call, ipc_callid_t hash)
+void ipcp_call_out(cap_phone_handle_t phandle, ipc_call_t *call,
+    cap_call_handle_t chandle)
 {
 	pending_call_t *pcall;
@@ -182,13 +186,14 @@
 	int i;
 
-	if (have_conn[phone]) proto = connections[phone].proto;
-	else proto = NULL;
+	if (have_conn[CAP_HANDLE_RAW(phandle)])
+		proto = connections[CAP_HANDLE_RAW(phandle)].proto;
+	else
+		proto = NULL;
 
 	args = call->args;
 
 	if ((display_mask & DM_IPC) != 0) {
-		printf("Call ID: %d, phone: %d, proto: %s, method: ",
-		    hash, phone,
-		    (proto ? proto->name : "n/a"));
+		printf("Call ID: %p, phone: %p, proto: %s, method: ",
+		    chandle, phandle, (proto ? proto->name : "n/a"));
 		ipc_m_print(proto, IPC_GET_IMETHOD(*call));
 		printf(" args: (%" PRIun ", %" PRIun ", %" PRIun ", "
@@ -208,6 +213,6 @@
 		if (oper != NULL) {
 
-			printf("%s(%d).%s", (proto ? proto->name : "n/a"),
-			    phone, (oper ? oper->name : "unknown"));
+			printf("%s(%p).%s", (proto ? proto->name : "n/a"),
+			    phandle, (oper ? oper->name : "unknown"));
 
 			putchar('(');
@@ -236,7 +241,7 @@
 
 	pcall = malloc(sizeof(pending_call_t));
-	pcall->phone_hash = phone;
+	pcall->phone_handle = phandle;
 	pcall->question = *call;
-	pcall->call_hash = hash;
+	pcall->call_handle = chandle;
 	pcall->oper = oper;
 
@@ -244,13 +249,13 @@
 }
 
-static void parse_answer(ipc_callid_t hash, pending_call_t *pcall,
+static void parse_answer(cap_call_handle_t call_handle, pending_call_t *pcall,
     ipc_call_t *answer)
 {
-	sysarg_t phone;
+	cap_phone_handle_t phone;
 	sysarg_t method;
 	sysarg_t service;
 	errno_t retval;
 	proto_t *proto;
-	int cphone;
+	cap_phone_handle_t cphone;
 
 	sysarg_t *resp;
@@ -258,5 +263,5 @@
 	int i;
 
-	phone = pcall->phone_hash;
+	phone = pcall->phone_handle;
 	method = IPC_GET_IMETHOD(pcall->question);
 	retval = IPC_GET_RETVAL(*answer);
@@ -265,7 +270,7 @@
 
 	if ((display_mask & DM_IPC) != 0) {
-		printf("Response to %d: retval=%s, args = (%" PRIun ", "
+		printf("Response to %p: retval=%s, args = (%" PRIun ", "
 		    "%" PRIun ", %" PRIun ", %" PRIun ", %" PRIun ")\n",
-		    hash, str_error_name(retval), IPC_GET_ARG1(*answer),
+		    call_handle, str_error_name(retval), IPC_GET_ARG1(*answer),
 		    IPC_GET_ARG2(*answer), IPC_GET_ARG3(*answer),
 		    IPC_GET_ARG4(*answer), IPC_GET_ARG5(*answer));
@@ -307,7 +312,7 @@
 			proto = proto_unknown;
 
-		cphone = IPC_GET_ARG5(*answer);
+		cphone = (cap_phone_handle_t) IPC_GET_ARG5(*answer);
 		if ((display_mask & DM_SYSTEM) != 0) {
-			printf("Registering connection (phone %d, protocol: %s)\n", cphone,
+			printf("Registering connection (phone %p, protocol: %s)\n", cphone,
 		    proto->name);
 		}
@@ -317,5 +322,5 @@
 }
 
-void ipcp_call_in(ipc_call_t *call, ipc_callid_t hash)
+void ipcp_call_in(ipc_call_t *call, cap_call_handle_t chandle)
 {
 	ht_link_t *item;
@@ -325,10 +330,10 @@
 		/* Not a response */
 		if ((display_mask & DM_IPC) != 0) {
-			printf("Not a response (hash %d)\n", hash);
+			printf("Not a response (handle %p)\n", chandle);
 		}
 		return;
 	}
 
-	item = hash_table_find(&pending_calls, &hash);
+	item = hash_table_find(&pending_calls, &chandle);
 	if (item == NULL)
 		return; /* No matching question found */
@@ -339,14 +344,14 @@
 
 	pcall = hash_table_get_inst(item, pending_call_t, link);
-	hash_table_remove(&pending_calls, &hash);
-
-	parse_answer(hash, pcall, call);
+	hash_table_remove(&pending_calls, &chandle);
+
+	parse_answer(chandle, pcall, call);
 	free(pcall);
 }
 
-void ipcp_hangup(int phone, errno_t rc)
+void ipcp_hangup(cap_phone_handle_t phone, errno_t rc)
 {
 	if ((display_mask & DM_SYSTEM) != 0) {
-		printf("Hang phone %d up -> %s\n", phone, str_error_name(rc));
+		printf("Hang up phone %p -> %s\n", phone, str_error_name(rc));
 		ipcp_connection_clear(phone);
 	}
Index: uspace/app/trace/ipcp.h
===================================================================
--- uspace/app/trace/ipcp.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/app/trace/ipcp.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -41,11 +41,11 @@
 void ipcp_cleanup(void);
 
-void ipcp_call_out(int phone, ipc_call_t *call, ipc_callid_t hash);
-void ipcp_call_sync(int phone, ipc_call_t *call, ipc_call_t *answer);
-void ipcp_call_in(ipc_call_t *call, ipc_callid_t hash);
-void ipcp_hangup(int phone, errno_t rc);
+void ipcp_call_out(cap_phone_handle_t, ipc_call_t *, cap_call_handle_t);
+void ipcp_call_sync(cap_phone_handle_t, ipc_call_t *call, ipc_call_t *answer);
+void ipcp_call_in(ipc_call_t *call, cap_call_handle_t);
+void ipcp_hangup(cap_phone_handle_t, errno_t);
 
-void ipcp_connection_set(int phone, int server, proto_t *proto);
-void ipcp_connection_clear(int phone);
+void ipcp_connection_set(cap_phone_handle_t, int server, proto_t *proto);
+void ipcp_connection_clear(cap_phone_handle_t);
 
 #endif
Index: uspace/app/trace/trace.c
===================================================================
--- uspace/app/trace/trace.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/app/trace/trace.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -282,10 +282,10 @@
 {
 	ipc_call_t call;
-	sysarg_t phoneid;
+	cap_phone_handle_t phandle;
 
 	if (sc_rc != EOK)
 		return;
 
-	phoneid = sc_args[0];
+	phandle = (cap_phone_handle_t) sc_args[0];
 
 	IPC_SET_IMETHOD(call, sc_args[1]);
@@ -296,5 +296,5 @@
 	IPC_SET_ARG5(call, 0);
 
-	ipcp_call_out(phoneid, &call, 0);
+	ipcp_call_out(phandle, &call, 0);
 }
 
@@ -311,9 +311,9 @@
 
 	if (rc == EOK) {
-		ipcp_call_out(sc_args[0], &call, 0);
-	}
-}
-
-static void sc_ipc_wait(sysarg_t *sc_args, int sc_rc)
+		ipcp_call_out((cap_phone_handle_t) sc_args[0], &call, 0);
+	}
+}
+
+static void sc_ipc_wait(sysarg_t *sc_args, cap_call_handle_t sc_rc)
 {
 	ipc_call_t call;
@@ -390,5 +390,5 @@
 		break;
 	case SYS_IPC_WAIT:
-		sc_ipc_wait(sc_args, sc_rc);
+		sc_ipc_wait(sc_args, (cap_call_handle_t) sc_rc);
 		break;
 	default:
Index: uspace/drv/audio/hdaudio/hdaudio.c
===================================================================
--- uspace/drv/audio/hdaudio/hdaudio.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/audio/hdaudio/hdaudio.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -263,5 +263,5 @@
 	}
 
-	int irq_cap;
+	cap_irq_handle_t irq_cap;
 	rc = register_interrupt_handler(dev, res.irqs.irqs[0],
 	    hdaudio_interrupt, &irq_code, &irq_cap);
Index: uspace/drv/audio/sb16/main.c
===================================================================
--- uspace/drv/audio/sb16/main.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/audio/sb16/main.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -93,5 +93,5 @@
 	irq_cmd_t irq_cmds[irq_cmd_count];
 	irq_pio_range_t irq_ranges[1];
-	int irq_cap;
+	cap_irq_handle_t irq_cap;
 
 	sb16_t *soft_state = ddf_dev_data_alloc(device, sizeof(sb16_t));
Index: uspace/drv/block/ahci/ahci.c
===================================================================
--- uspace/drv/block/ahci/ahci.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/block/ahci/ahci.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -1184,5 +1184,5 @@
 	ct.ranges = ahci_ranges;
 
-	int irq_cap;
+	cap_irq_handle_t irq_cap;
 	errno_t rc = register_interrupt_handler(dev,
 	    hw_res_parsed.irqs.irqs[0], ahci_interrupt, &ct, &irq_cap);
Index: uspace/drv/block/ddisk/ddisk.c
===================================================================
--- uspace/drv/block/ddisk/ddisk.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/block/ddisk/ddisk.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -112,5 +112,5 @@
 	ddisk_regs_t *ddisk_regs;
 
-	int irq_cap;
+	cap_irq_handle_t irq_cap;
 
 	bd_srvs_t bds;
@@ -449,5 +449,5 @@
 	ddisk->bds.sarg = ddisk;
 
-	ddisk->irq_cap = -1;
+	ddisk->irq_cap = CAP_NIL;
 
 	/*
Index: uspace/drv/bus/usb/ohci/hc.c
===================================================================
--- uspace/drv/bus/usb/ohci/hc.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/bus/usb/ohci/hc.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -512,5 +512,5 @@
 
 	/* Enable interrupts */
-	if (instance->base.irq_cap >= 0) {
+	if (CAP_HANDLE_VALID(instance->base.irq_handle)) {
 		OHCI_WR(instance->registers->interrupt_enable,
 		    OHCI_USED_INTERRUPTS);
Index: uspace/drv/bus/usb/uhci/hc.c
===================================================================
--- uspace/drv/bus/usb/uhci/hc.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/bus/usb/uhci/hc.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -294,5 +294,5 @@
 	pio_write_32(&registers->flbaseadd, pa);
 
-	if (instance->base.irq_cap >= 0) {
+	if (CAP_HANDLE_VALID(instance->base.irq_handle)) {
 		/* Enable all interrupts, but resume interrupt */
 		pio_write_16(&instance->registers->usbintr,
Index: uspace/drv/bus/usb/xhci/hc.c
===================================================================
--- uspace/drv/bus/usb/xhci/hc.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/bus/usb/xhci/hc.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -495,5 +495,5 @@
 	XHCI_REG_WR(intr0, XHCI_INTR_ERSTBA, erstba_phys);
 
-	if (hc->base.irq_cap > 0) {
+	if (CAP_HANDLE_VALID(hc->base.irq_handle)) {
 		XHCI_REG_SET(intr0, XHCI_INTR_IE, 1);
 		XHCI_REG_SET(hc->op_regs, XHCI_OP_INTE, 1);
Index: uspace/drv/char/i8042/i8042.c
===================================================================
--- uspace/drv/char/i8042/i8042.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/char/i8042/i8042.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -281,7 +281,7 @@
 	};
 
-	int irq_kbd_cap;
+	cap_irq_handle_t kbd_ihandle;
 	rc = register_interrupt_handler(ddf_dev, irq_kbd,
-	    i8042_irq_handler, &irq_code, &irq_kbd_cap);
+	    i8042_irq_handler, &irq_code, &kbd_ihandle);
 	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed set handler for kbd: %s.",
@@ -290,7 +290,7 @@
 	}
 
-	int irq_mouse_cap;
+	cap_irq_handle_t mouse_ihandle;
 	rc = register_interrupt_handler(ddf_dev, irq_mouse,
-	    i8042_irq_handler, &irq_code, &irq_mouse_cap);
+	    i8042_irq_handler, &irq_code, &mouse_ihandle);
 	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed set handler for mouse: %s.",
Index: uspace/drv/char/msim-con/msim-con.c
===================================================================
--- uspace/drv/char/msim-con/msim-con.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/char/msim-con/msim-con.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -83,5 +83,4 @@
 {
 	ddf_fun_t *fun = NULL;
-	bool subscribed = false;
 	irq_cmd_t *msim_cmds = NULL;
 	errno_t rc;
@@ -90,4 +89,6 @@
 	fibril_mutex_initialize(&con->buf_lock);
 	fibril_condvar_initialize(&con->buf_cv);
+
+	con->irq_handle = CAP_NIL;
 
 	msim_cmds = malloc(sizeof(msim_cmds_proto));
@@ -125,6 +126,10 @@
 	con->irq_code.cmds = msim_cmds;
 
-	async_irq_subscribe(res->irq, msim_irq_handler, con, &con->irq_code, NULL);
-	subscribed = true;
+	rc = async_irq_subscribe(res->irq, msim_irq_handler, con,
+	    &con->irq_code, &con->irq_handle);
+	if (rc != EOK) {
+		ddf_msg(LVL_ERROR, "Error registering IRQ code.");
+		goto error;
+	}
 
 	chardev_srvs_init(&con->cds);
@@ -142,6 +147,6 @@
 	return EOK;
 error:
-	if (subscribed)
-		async_irq_unsubscribe(res->irq);
+	if (CAP_HANDLE_VALID(con->irq_handle))
+		async_irq_unsubscribe(con->irq_handle);
 	if (fun != NULL)
 		ddf_fun_destroy(fun);
Index: uspace/drv/char/msim-con/msim-con.h
===================================================================
--- uspace/drv/char/msim-con/msim-con.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/char/msim-con/msim-con.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -68,4 +68,5 @@
 	fibril_condvar_t buf_cv;
 	ioport8_t *out_reg;
+	cap_irq_handle_t irq_handle;
 } msim_con_t;
 
Index: uspace/drv/char/ns8250/ns8250.c
===================================================================
--- uspace/drv/char/ns8250/ns8250.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/char/ns8250/ns8250.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -165,5 +165,5 @@
 	int irq;
 	/** IRQ capability handle */
-	int irq_cap;
+	cap_irq_handle_t irq_handle;
 	/** The base i/o address of the devices registers. */
 	uintptr_t io_addr;
@@ -804,8 +804,8 @@
  */
 static inline errno_t ns8250_register_interrupt_handler(ns8250_t *ns,
-    cap_handle_t *handle)
+    cap_irq_handle_t *ihandle)
 {
 	return register_interrupt_handler(ns->dev, ns->irq,
-	    ns8250_interrupt_handler, NULL, handle);
+	    ns8250_interrupt_handler, NULL, ihandle);
 }
 
@@ -816,5 +816,5 @@
 static inline errno_t ns8250_unregister_interrupt_handler(ns8250_t *ns)
 {
-	return unregister_interrupt_handler(ns->dev, ns->irq_cap);
+	return unregister_interrupt_handler(ns->dev, ns->irq_handle);
 }
 
@@ -876,5 +876,6 @@
 
 	/* Register interrupt handler. */
-	rc = ns8250_register_interrupt_handler(ns, &ns->irq_cap);
+	ns->irq_handle = CAP_NIL;
+	rc = ns8250_register_interrupt_handler(ns, &ns->irq_handle);
 	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed to register interrupt handler.");
Index: uspace/drv/char/pl050/pl050.c
===================================================================
--- uspace/drv/char/pl050/pl050.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/char/pl050/pl050.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -213,7 +213,7 @@
 	pl050->regs = regs;
 
-	int irq_cap;
+	cap_irq_handle_t ihandle;
 	rc = register_interrupt_handler(pl050->dev,
-	    res.irqs.irqs[0], pl050_interrupt, &pl050_irq_code, &irq_cap);
+	    res.irqs.irqs[0], pl050_interrupt, &pl050_irq_code, &ihandle);
 	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed registering interrupt handler. (%s)",
Index: uspace/drv/nic/e1k/e1k.c
===================================================================
--- uspace/drv/nic/e1k/e1k.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/nic/e1k/e1k.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -1264,5 +1264,6 @@
  *
  */
-inline static errno_t e1000_register_int_handler(nic_t *nic, cap_handle_t *handle)
+inline static errno_t e1000_register_int_handler(nic_t *nic,
+    cap_irq_handle_t *handle)
 {
 	e1000_t *e1000 = DRIVER_DATA_NIC(nic);
@@ -2165,6 +2166,6 @@
 	ddf_fun_set_ops(fun, &e1000_dev_ops);
 
-	int irq_cap;
-	rc = e1000_register_int_handler(nic, &irq_cap);
+	cap_irq_handle_t irq_handle;
+	rc = e1000_register_int_handler(nic, &irq_handle);
 	if (rc != EOK) {
 		goto err_fun_create;
@@ -2204,5 +2205,5 @@
 	e1000_uninitialize_rx_structure(nic);
 err_irq:
-	unregister_interrupt_handler(dev, irq_cap);
+	unregister_interrupt_handler(dev, irq_handle);
 err_fun_create:
 	ddf_fun_destroy(fun);
Index: uspace/drv/nic/ne2k/ne2k.c
===================================================================
--- uspace/drv/nic/ne2k/ne2k.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/nic/ne2k/ne2k.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -124,5 +124,6 @@
 static void ne2k_interrupt_handler(ipc_call_t *, ddf_dev_t *);
 
-static errno_t ne2k_register_interrupt(nic_t *nic_data, cap_handle_t *handle)
+static errno_t ne2k_register_interrupt(nic_t *nic_data,
+    cap_irq_handle_t *handle)
 {
 	ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
Index: uspace/drv/nic/rtl8139/driver.c
===================================================================
--- uspace/drv/nic/rtl8139/driver.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/nic/rtl8139/driver.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -846,5 +846,6 @@
  *  @return An error code otherwise.
  */
-inline static errno_t rtl8139_register_int_handler(nic_t *nic_data, cap_handle_t *handle)
+inline static errno_t rtl8139_register_int_handler(nic_t *nic_data,
+    cap_irq_handle_t *handle)
 {
 	rtl8139_t *rtl8139 = nic_get_specific(nic_data);
@@ -1288,6 +1289,6 @@
 
 	/* Register interrupt handler */
-	int irq_cap;
-	rc = rtl8139_register_int_handler(nic_data, &irq_cap);
+	cap_irq_handle_t irq_handle;
+	rc = rtl8139_register_int_handler(nic_data, &irq_handle);
 	if (rc != EOK) {
 		goto err_pio;
@@ -1324,5 +1325,5 @@
 	ddf_fun_destroy(fun);
 err_srv:
-	unregister_interrupt_handler(dev, irq_cap);
+	unregister_interrupt_handler(dev, irq_handle);
 err_pio:
 	// rtl8139_pio_disable(dev);
Index: uspace/drv/nic/rtl8169/driver.c
===================================================================
--- uspace/drv/nic/rtl8169/driver.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/drv/nic/rtl8169/driver.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -75,5 +75,6 @@
 static void rtl8169_send_frame(nic_t *nic_data, void *data, size_t size);
 static void rtl8169_irq_handler(ipc_call_t *icall, ddf_dev_t *dev);
-static inline errno_t rtl8169_register_int_handler(nic_t *nic_data, cap_handle_t *handle);
+static inline errno_t rtl8169_register_int_handler(nic_t *nic_data,
+    cap_irq_handle_t *handle);
 static inline void rtl8169_get_hwaddr(rtl8169_t *rtl8169, nic_address_t *addr);
 static inline void rtl8169_set_hwaddr(rtl8169_t *rtl8169, const nic_address_t *addr);
@@ -361,5 +362,6 @@
 }
 
-inline static errno_t rtl8169_register_int_handler(nic_t *nic_data, cap_handle_t *handle)
+inline static errno_t rtl8169_register_int_handler(nic_t *nic_data,
+    cap_irq_handle_t *handle)
 {
 	rtl8169_t *rtl8169 = nic_get_specific(nic_data);
@@ -429,6 +431,6 @@
 		goto err_pio;
 
-	int irq_cap;
-	rc = rtl8169_register_int_handler(nic_data, &irq_cap);
+	cap_irq_handle_t irq_handle;
+	rc = rtl8169_register_int_handler(nic_data, &irq_handle);
 	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed to register IRQ handler (%s)", str_error_name(rc));
@@ -472,5 +474,5 @@
 err_srv:
 	/* XXX Disconnect from services */
-	unregister_interrupt_handler(dev, irq_cap);
+	unregister_interrupt_handler(dev, irq_handle);
 err_irq:
 err_pio:
Index: uspace/lib/c/generic/async.c
===================================================================
--- uspace/lib/c/generic/async.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/c/generic/async.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -133,5 +133,5 @@
 
 	/** Session identification */
-	int phone;
+	cap_phone_handle_t phone;
 
 	/** First clone connection argument */
@@ -169,5 +169,5 @@
 
 	/** Exchange identification */
-	int phone;
+	cap_phone_handle_t phone;
 };
 
@@ -185,5 +185,5 @@
 	link_t link;
 
-	cap_handle_t chandle;
+	cap_call_handle_t chandle;
 	ipc_call_t call;
 } msg_t;
@@ -237,5 +237,5 @@
 
 	/** Identification of the opening call. */
-	cap_handle_t chandle;
+	cap_call_handle_t chandle;
 
 	/** Call data of the opening call. */
@@ -243,5 +243,5 @@
 
 	/** Identification of the closing call. */
-	cap_handle_t close_chandle;
+	cap_call_handle_t close_chandle;
 
 	/** Fibril function that will be used to handle the connection. */
@@ -382,5 +382,5 @@
  *
  */
-static void default_fallback_port_handler(cap_handle_t chandle,
+static void default_fallback_port_handler(cap_call_handle_t chandle,
     ipc_call_t *call, void *arg)
 {
@@ -786,5 +786,5 @@
  */
 static fid_t async_new_connection(task_id_t in_task_id, sysarg_t in_phone_hash,
-    cap_handle_t chandle, ipc_call_t *call, async_port_handler_t handler,
+    cap_call_handle_t chandle, ipc_call_t *call, async_port_handler_t handler,
     void *data)
 {
@@ -968,5 +968,5 @@
  *
  */
-static bool route_call(cap_handle_t chandle, ipc_call_t *call)
+static bool route_call(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(call);
@@ -1057,5 +1057,5 @@
  */
 errno_t async_irq_subscribe(int inr, async_notification_handler_t handler,
-    void *data, const irq_code_t *ucode, cap_handle_t *handle)
+    void *data, const irq_code_t *ucode, cap_irq_handle_t *handle)
 {
 	notification_t *notification =
@@ -1077,8 +1077,8 @@
 	futex_up(&async_futex);
 
-	cap_handle_t cap;
-	errno_t rc = ipc_irq_subscribe(inr, imethod, ucode, &cap);
+	cap_irq_handle_t ihandle;
+	errno_t rc = ipc_irq_subscribe(inr, imethod, ucode, &ihandle);
 	if (rc == EOK && handle != NULL) {
-		*handle = cap;
+		*handle = ihandle;
 	}
 	return rc;
@@ -1087,15 +1087,15 @@
 /** Unsubscribe from IRQ notification.
  *
- * @param cap     IRQ capability handle.
+ * @param handle  IRQ capability handle.
  *
  * @return Zero on success or an error code.
  *
  */
-errno_t async_irq_unsubscribe(int cap)
+errno_t async_irq_unsubscribe(cap_irq_handle_t ihandle)
 {
 	// TODO: Remove entry from hash table
 	//       to avoid memory leak
 
-	return ipc_irq_unsubscribe(cap);
+	return ipc_irq_unsubscribe(ihandle);
 }
 
@@ -1200,5 +1200,5 @@
  *          message. In that case zero CAP_NIL is returned.
  */
-cap_handle_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs)
+cap_call_handle_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs)
 {
 	assert(call);
@@ -1267,5 +1267,5 @@
 	list_remove(&msg->link);
 
-	cap_handle_t chandle = msg->chandle;
+	cap_call_handle_t chandle = msg->chandle;
 	*call = msg->call;
 	free(msg);
@@ -1339,5 +1339,5 @@
  *
  */
-static void handle_call(cap_handle_t chandle, ipc_call_t *call)
+static void handle_call(cap_call_handle_t chandle, ipc_call_t *call)
 {
 	assert(call);
@@ -2042,15 +2042,15 @@
 }
 
-errno_t async_answer_0(cap_handle_t chandle, errno_t retval)
+errno_t async_answer_0(cap_call_handle_t chandle, errno_t retval)
 {
 	return ipc_answer_0(chandle, retval);
 }
 
-errno_t async_answer_1(cap_handle_t chandle, errno_t retval, sysarg_t arg1)
+errno_t async_answer_1(cap_call_handle_t chandle, errno_t retval, sysarg_t arg1)
 {
 	return ipc_answer_1(chandle, retval, arg1);
 }
 
-errno_t async_answer_2(cap_handle_t chandle, errno_t retval, sysarg_t arg1,
+errno_t async_answer_2(cap_call_handle_t chandle, errno_t retval, sysarg_t arg1,
     sysarg_t arg2)
 {
@@ -2058,5 +2058,5 @@
 }
 
-errno_t async_answer_3(cap_handle_t chandle, errno_t retval, sysarg_t arg1,
+errno_t async_answer_3(cap_call_handle_t chandle, errno_t retval, sysarg_t arg1,
     sysarg_t arg2, sysarg_t arg3)
 {
@@ -2064,5 +2064,5 @@
 }
 
-errno_t async_answer_4(cap_handle_t chandle, errno_t retval, sysarg_t arg1,
+errno_t async_answer_4(cap_call_handle_t chandle, errno_t retval, sysarg_t arg1,
     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
 {
@@ -2070,5 +2070,5 @@
 }
 
-errno_t async_answer_5(cap_handle_t chandle, errno_t retval, sysarg_t arg1,
+errno_t async_answer_5(cap_call_handle_t chandle, errno_t retval, sysarg_t arg1,
     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
 {
@@ -2076,5 +2076,5 @@
 }
 
-errno_t async_forward_fast(cap_handle_t chandle, async_exch_t *exch,
+errno_t async_forward_fast(cap_call_handle_t chandle, async_exch_t *exch,
     sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
 {
@@ -2085,5 +2085,5 @@
 }
 
-errno_t async_forward_slow(cap_handle_t chandle, async_exch_t *exch,
+errno_t async_forward_slow(cap_call_handle_t chandle, async_exch_t *exch,
     sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
     sysarg_t arg4, sysarg_t arg5, unsigned int mode)
@@ -2126,6 +2126,7 @@
 }
 
-static errno_t async_connect_me_to_internal(int phone, sysarg_t arg1, sysarg_t arg2,
-    sysarg_t arg3, sysarg_t arg4, int *out_phone)
+static errno_t async_connect_me_to_internal(cap_phone_handle_t phone,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4,
+    cap_phone_handle_t *out_phone)
 {
 	ipc_call_t result;
@@ -2133,5 +2134,5 @@
 	// XXX: Workaround for GCC's inability to infer association between
 	// rc == EOK and *out_phone being assigned.
-	*out_phone = -1;
+	*out_phone = CAP_NIL;
 
 	amsg_t *msg = amsg_create();
@@ -2151,5 +2152,5 @@
 		return rc;
 
-	*out_phone = (int) IPC_GET_ARG5(result);
+	*out_phone = (cap_phone_handle_t) IPC_GET_ARG5(result);
 	return EOK;
 }
@@ -2182,5 +2183,5 @@
 	}
 
-	int phone;
+	cap_phone_handle_t phone;
 	errno_t rc = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
 	    0, &phone);
@@ -2235,5 +2236,5 @@
 	}
 
-	int phone;
+	cap_phone_handle_t phone;
 	errno_t rc = async_connect_me_to_internal(exch->phone, iface, arg2,
 	    arg3, 0, &phone);
@@ -2306,5 +2307,5 @@
 	}
 
-	int phone;
+	cap_phone_handle_t phone;
 	errno_t rc = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
 	    IPC_FLAG_BLOCKING, &phone);
@@ -2360,5 +2361,5 @@
 	}
 
-	int phone;
+	cap_phone_handle_t phone;
 	errno_t rc = async_connect_me_to_internal(exch->phone, iface, arg2,
 	    arg3, IPC_FLAG_BLOCKING, &phone);
@@ -2396,5 +2397,5 @@
 	}
 
-	cap_handle_t phone;
+	cap_phone_handle_t phone;
 	errno_t rc = ipc_connect_kbox(id, &phone);
 	if (rc != EOK) {
@@ -2421,5 +2422,5 @@
 }
 
-static errno_t async_hangup_internal(int phone)
+static errno_t async_hangup_internal(cap_phone_handle_t phone)
 {
 	return ipc_hangup(phone);
@@ -2515,5 +2516,5 @@
 			}
 		} else if (mgmt == EXCHANGE_PARALLEL) {
-			int phone;
+			cap_phone_handle_t phone;
 			errno_t rc;
 
@@ -2645,5 +2646,5 @@
  *
  */
-bool async_share_in_receive(cap_handle_t *chandle, size_t *size)
+bool async_share_in_receive(cap_call_handle_t *chandle, size_t *size)
 {
 	assert(chandle);
@@ -2673,5 +2674,6 @@
  *
  */
-errno_t async_share_in_finalize(cap_handle_t chandle, void *src, unsigned int flags)
+errno_t async_share_in_finalize(cap_call_handle_t chandle, void *src,
+    unsigned int flags)
 {
 	return ipc_answer_3(chandle, EOK, (sysarg_t) src, (sysarg_t) flags,
@@ -2712,5 +2714,5 @@
  *
  */
-bool async_share_out_receive(cap_handle_t *chandle, size_t *size,
+bool async_share_out_receive(cap_call_handle_t *chandle, size_t *size,
     unsigned int *flags)
 {
@@ -2743,5 +2745,5 @@
  *
  */
-errno_t async_share_out_finalize(cap_handle_t chandle, void **dst)
+errno_t async_share_out_finalize(cap_call_handle_t chandle, void **dst)
 {
 	return ipc_answer_2(chandle, EOK, (sysarg_t) __entry, (sysarg_t) dst);
@@ -2797,5 +2799,5 @@
  *
  */
-bool async_data_read_receive(cap_handle_t *chandle, size_t *size)
+bool async_data_read_receive(cap_call_handle_t *chandle, size_t *size)
 {
 	ipc_call_t data;
@@ -2817,5 +2819,5 @@
  *
  */
-bool async_data_read_receive_call(cap_handle_t *chandle, ipc_call_t *data,
+bool async_data_read_receive_call(cap_call_handle_t *chandle, ipc_call_t *data,
     size_t *size)
 {
@@ -2848,5 +2850,6 @@
  *
  */
-errno_t async_data_read_finalize(cap_handle_t chandle, const void *src, size_t size)
+errno_t async_data_read_finalize(cap_call_handle_t chandle, const void *src,
+    size_t size)
 {
 	return ipc_answer_2(chandle, EOK, (sysarg_t) src, (sysarg_t) size);
@@ -2863,5 +2866,5 @@
 		return ENOENT;
 
-	cap_handle_t chandle;
+	cap_call_handle_t chandle;
 	if (!async_data_read_receive(&chandle, NULL)) {
 		ipc_answer_0(chandle, EINVAL);
@@ -2922,5 +2925,5 @@
  *
  */
-bool async_data_write_receive(cap_handle_t *chandle, size_t *size)
+bool async_data_write_receive(cap_call_handle_t *chandle, size_t *size)
 {
 	ipc_call_t data;
@@ -2943,5 +2946,5 @@
  *
  */
-bool async_data_write_receive_call(cap_handle_t *chandle, ipc_call_t *data,
+bool async_data_write_receive_call(cap_call_handle_t *chandle, ipc_call_t *data,
     size_t *size)
 {
@@ -2973,5 +2976,6 @@
  *
  */
-errno_t async_data_write_finalize(cap_handle_t chandle, void *dst, size_t size)
+errno_t async_data_write_finalize(cap_call_handle_t chandle, void *dst,
+    size_t size)
 {
 	return ipc_answer_2(chandle, EOK, (sysarg_t) dst, (sysarg_t) size);
@@ -3005,5 +3009,5 @@
 	assert(data);
 
-	cap_handle_t chandle;
+	cap_call_handle_t chandle;
 	size_t size;
 	if (!async_data_write_receive(&chandle, &size)) {
@@ -3064,5 +3068,5 @@
 void async_data_write_void(errno_t retval)
 {
-	cap_handle_t chandle;
+	cap_call_handle_t chandle;
 	async_data_write_receive(&chandle, NULL);
 	ipc_answer_0(chandle, retval);
@@ -3079,5 +3083,5 @@
 		return ENOENT;
 
-	cap_handle_t chandle;
+	cap_call_handle_t chandle;
 	if (!async_data_write_receive(&chandle, NULL)) {
 		ipc_answer_0(chandle, EINVAL);
@@ -3121,8 +3125,9 @@
 	/* Accept the phone */
 	ipc_call_t call;
-	cap_handle_t chandle = async_get_call(&call);
-	cap_handle_t phandle = (cap_handle_t) IPC_GET_ARG5(call);
-
-	if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) || (phandle < 0)) {
+	cap_call_handle_t chandle = async_get_call(&call);
+	cap_phone_handle_t phandle = (cap_handle_t) IPC_GET_ARG5(call);
+
+	if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) ||
+	    !CAP_HANDLE_VALID((phandle))) {
 		async_answer_0(chandle, EINVAL);
 		return NULL;
@@ -3171,7 +3176,8 @@
 async_sess_t *async_callback_receive_start(exch_mgmt_t mgmt, ipc_call_t *call)
 {
-	cap_handle_t phandle = (cap_handle_t) IPC_GET_ARG5(*call);
-
-	if ((IPC_GET_IMETHOD(*call) != IPC_M_CONNECT_TO_ME) || (phandle < 0))
+	cap_phone_handle_t phandle = (cap_handle_t) IPC_GET_ARG5(*call);
+
+	if ((IPC_GET_IMETHOD(*call) != IPC_M_CONNECT_TO_ME) ||
+	    !CAP_HANDLE_VALID((phandle)))
 		return NULL;
 
@@ -3201,8 +3207,8 @@
 {
 	return async_req_5_0(exch, IPC_M_STATE_CHANGE_AUTHORIZE,
-	    arg1, arg2, arg3, 0, other_exch->phone);
-}
-
-bool async_state_change_receive(cap_handle_t *chandle, sysarg_t *arg1,
+	    arg1, arg2, arg3, 0, CAP_HANDLE_RAW(other_exch->phone));
+}
+
+bool async_state_change_receive(cap_call_handle_t *chandle, sysarg_t *arg1,
     sysarg_t *arg2, sysarg_t *arg3)
 {
@@ -3225,7 +3231,8 @@
 }
 
-errno_t async_state_change_finalize(cap_handle_t chandle, async_exch_t *other_exch)
-{
-	return ipc_answer_1(chandle, EOK, other_exch->phone);
+errno_t async_state_change_finalize(cap_call_handle_t chandle,
+    async_exch_t *other_exch)
+{
+	return ipc_answer_1(chandle, EOK, CAP_HANDLE_RAW(other_exch->phone));
 }
 
Index: uspace/lib/c/generic/ipc.c
===================================================================
--- uspace/lib/c/generic/ipc.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/c/generic/ipc.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -129,6 +129,7 @@
  * @param callback  Answer or error callback.
  */
-void ipc_call_async_fast(cap_handle_t phandle, sysarg_t imethod, sysarg_t arg1,
-    sysarg_t arg2, sysarg_t arg3, void *private, ipc_async_callback_t callback)
+void ipc_call_async_fast(cap_phone_handle_t phandle, sysarg_t imethod,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, void *private,
+    ipc_async_callback_t callback)
 {
 	async_call_t *call = ipc_prepare_async(private, callback);
@@ -136,6 +137,7 @@
 		return;
 
-	errno_t rc = (errno_t) __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phandle, imethod, arg1,
-	    arg2, arg3, (sysarg_t) call);
+	errno_t rc = (errno_t) __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST,
+	    CAP_HANDLE_RAW(phandle), imethod, arg1, arg2, arg3,
+	    (sysarg_t) call);
 
 	ipc_finish_async(rc, call);
@@ -160,7 +162,7 @@
  * @param callback  Answer or error callback.
  */
-void ipc_call_async_slow(int phandle, sysarg_t imethod, sysarg_t arg1,
-    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, void *private,
-    ipc_async_callback_t callback)
+void ipc_call_async_slow(cap_phone_handle_t phandle, sysarg_t imethod,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
+    void *private, ipc_async_callback_t callback)
 {
 	async_call_t *call = ipc_prepare_async(private, callback);
@@ -175,6 +177,7 @@
 	IPC_SET_ARG5(call->msg.data, arg5);
 
-	errno_t rc = (errno_t) __SYSCALL3(SYS_IPC_CALL_ASYNC_SLOW, phandle,
-	    (sysarg_t) &call->msg.data, (sysarg_t) call);
+	errno_t rc = (errno_t) __SYSCALL3(SYS_IPC_CALL_ASYNC_SLOW,
+	    CAP_HANDLE_RAW(phandle), (sysarg_t) &call->msg.data,
+	    (sysarg_t) call);
 
 	ipc_finish_async(rc, call);
@@ -197,9 +200,9 @@
  *
  */
-errno_t ipc_answer_fast(cap_handle_t chandle, errno_t retval, sysarg_t arg1,
-    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
-{
-	return (errno_t) __SYSCALL6(SYS_IPC_ANSWER_FAST, chandle, (sysarg_t) retval, arg1, arg2,
-	    arg3, arg4);
+errno_t ipc_answer_fast(cap_call_handle_t chandle, errno_t retval,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
+{
+	return (errno_t) __SYSCALL6(SYS_IPC_ANSWER_FAST,
+	    CAP_HANDLE_RAW(chandle), (sysarg_t) retval, arg1, arg2, arg3, arg4);
 }
 
@@ -218,6 +221,6 @@
  *
  */
-errno_t ipc_answer_slow(cap_handle_t chandle, errno_t retval, sysarg_t arg1,
-    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
+errno_t ipc_answer_slow(cap_call_handle_t chandle, errno_t retval,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
 {
 	ipc_call_t data;
@@ -230,5 +233,6 @@
 	IPC_SET_ARG5(data, arg5);
 
-	return (errno_t) __SYSCALL2(SYS_IPC_ANSWER_SLOW, chandle, (sysarg_t) &data);
+	return (errno_t) __SYSCALL2(SYS_IPC_ANSWER_SLOW,
+	    CAP_HANDLE_RAW(chandle), (sysarg_t) &data);
 }
 
@@ -251,8 +255,7 @@
 /** Wait for first IPC call to come.
  *
- * @param call   Incoming call storage.
- * @param usec   Timeout in microseconds
- * @param flags  Flags passed to SYS_IPC_WAIT (blocking, nonblocking).
- * @param[out] out_handle  Call handle.
+ * @param[out] call   Storage for the received call.
+ * @param[in]  usec   Timeout in microseconds
+ * @param[in[  flags  Flags passed to SYS_IPC_WAIT (blocking, nonblocking).
  *
  * @return  Error code.
@@ -260,5 +263,6 @@
 errno_t ipc_wait_cycle(ipc_call_t *call, sysarg_t usec, unsigned int flags)
 {
-	errno_t rc = (errno_t) __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
+	errno_t rc = (errno_t) __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec,
+	    flags);
 
 	/* Handle received answers */
@@ -295,5 +299,6 @@
 	do {
 		rc = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);
-	} while ((rc == EOK) && (call->cap_handle == CAP_NIL) && (call->flags & IPC_CALL_ANSWERED));
+	} while ((rc == EOK) && (call->cap_handle == CAP_NIL) &&
+	    (call->flags & IPC_CALL_ANSWERED));
 
 	return rc;
@@ -316,5 +321,6 @@
 		rc = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT,
 		    SYNCH_FLAGS_NON_BLOCKING);
-	} while ((rc == EOK) && (call->cap_handle == CAP_NIL) && (call->flags & IPC_CALL_ANSWERED));
+	} while ((rc == EOK) && (call->cap_handle == CAP_NIL) &&
+	    (call->flags & IPC_CALL_ANSWERED));
 
 	return rc;
@@ -328,7 +334,7 @@
  *
  */
-errno_t ipc_hangup(cap_handle_t phandle)
-{
-	return (errno_t) __SYSCALL1(SYS_IPC_HANGUP, phandle);
+errno_t ipc_hangup(cap_phone_handle_t phandle)
+{
+	return (errno_t) __SYSCALL1(SYS_IPC_HANGUP, CAP_HANDLE_RAW(phandle));
 }
 
@@ -350,12 +356,13 @@
  *
  */
-errno_t ipc_forward_fast(cap_handle_t chandle, cap_handle_t phandle,
+errno_t ipc_forward_fast(cap_call_handle_t chandle, cap_phone_handle_t phandle,
     sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
 {
-	return (errno_t) __SYSCALL6(SYS_IPC_FORWARD_FAST, chandle, phandle, imethod, arg1,
+	return (errno_t) __SYSCALL6(SYS_IPC_FORWARD_FAST,
+	    CAP_HANDLE_RAW(chandle), CAP_HANDLE_RAW(phandle), imethod, arg1,
 	    arg2, mode);
 }
 
-errno_t ipc_forward_slow(cap_handle_t chandle, cap_handle_t phandle,
+errno_t ipc_forward_slow(cap_call_handle_t chandle, cap_phone_handle_t phandle,
     sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
     sysarg_t arg4, sysarg_t arg5, unsigned int mode)
@@ -370,6 +377,7 @@
 	IPC_SET_ARG5(data, arg5);
 
-	return (errno_t) __SYSCALL4(SYS_IPC_FORWARD_SLOW, chandle, phandle,
-	    (sysarg_t) &data, mode);
+	return (errno_t) __SYSCALL4(SYS_IPC_FORWARD_SLOW,
+	    CAP_HANDLE_RAW(chandle), CAP_HANDLE_RAW(phandle), (sysarg_t) &data,
+	    mode);
 }
 
@@ -377,5 +385,5 @@
  *
  */
-errno_t ipc_connect_kbox(task_id_t id, cap_handle_t *phone)
+errno_t ipc_connect_kbox(task_id_t id, cap_phone_handle_t *phone)
 {
 	return (errno_t) __SYSCALL2(SYS_IPC_CONNECT_KBOX, (sysarg_t) &id, (sysarg_t) phone);
Index: uspace/lib/c/generic/irq.c
===================================================================
--- uspace/lib/c/generic/irq.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/c/generic/irq.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -64,11 +64,11 @@
  */
 errno_t ipc_irq_subscribe(int inr, sysarg_t method, const irq_code_t *ucode,
-    cap_handle_t *out_handle)
+    cap_irq_handle_t *out_handle)
 {
 	if (ucode == NULL)
 		ucode = &default_ucode;
 
-	return (errno_t) __SYSCALL4(SYS_IPC_IRQ_SUBSCRIBE, inr, method, (sysarg_t) ucode,
-	    (sysarg_t) out_handle);
+	return (errno_t) __SYSCALL4(SYS_IPC_IRQ_SUBSCRIBE, inr, method,
+	    (sysarg_t) ucode, (sysarg_t) out_handle);
 }
 
@@ -80,7 +80,8 @@
  *
  */
-errno_t ipc_irq_unsubscribe(cap_handle_t cap)
+errno_t ipc_irq_unsubscribe(cap_irq_handle_t cap)
 {
-	return (errno_t) __SYSCALL1(SYS_IPC_IRQ_UNSUBSCRIBE, cap);
+	return (errno_t) __SYSCALL1(SYS_IPC_IRQ_UNSUBSCRIBE,
+	    CAP_HANDLE_RAW(cap));
 }
 
Index: uspace/lib/c/include/async.h
===================================================================
--- uspace/lib/c/include/async.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/c/include/async.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -66,5 +66,5 @@
  *
  */
-typedef void (*async_port_handler_t)(cap_handle_t, ipc_call_t *, void *);
+typedef void (*async_port_handler_t)(cap_call_handle_t, ipc_call_t *, void *);
 
 /** Notification handler */
@@ -119,5 +119,5 @@
 	async_get_call_timeout(data, 0)
 
-extern cap_handle_t async_get_call_timeout(ipc_call_t *, suseconds_t);
+extern cap_call_handle_t async_get_call_timeout(ipc_call_t *, suseconds_t);
 
 /*
@@ -169,6 +169,6 @@
 
 extern errno_t async_irq_subscribe(int, async_notification_handler_t, void *,
-    const irq_code_t *, cap_handle_t *);
-extern errno_t async_irq_unsubscribe(cap_handle_t);
+    const irq_code_t *, cap_irq_handle_t *);
+extern errno_t async_irq_unsubscribe(cap_irq_handle_t);
 
 extern errno_t async_event_subscribe(event_type_t, async_notification_handler_t,
@@ -198,12 +198,12 @@
  */
 
-extern errno_t async_answer_0(cap_handle_t, errno_t);
-extern errno_t async_answer_1(cap_handle_t, errno_t, sysarg_t);
-extern errno_t async_answer_2(cap_handle_t, errno_t, sysarg_t, sysarg_t);
-extern errno_t async_answer_3(cap_handle_t, errno_t, sysarg_t, sysarg_t,
+extern errno_t async_answer_0(cap_call_handle_t, errno_t);
+extern errno_t async_answer_1(cap_call_handle_t, errno_t, sysarg_t);
+extern errno_t async_answer_2(cap_call_handle_t, errno_t, sysarg_t, sysarg_t);
+extern errno_t async_answer_3(cap_call_handle_t, errno_t, sysarg_t, sysarg_t,
     sysarg_t);
-extern errno_t async_answer_4(cap_handle_t, errno_t, sysarg_t, sysarg_t,
+extern errno_t async_answer_4(cap_call_handle_t, errno_t, sysarg_t, sysarg_t,
     sysarg_t, sysarg_t);
-extern errno_t async_answer_5(cap_handle_t, errno_t, sysarg_t, sysarg_t,
+extern errno_t async_answer_5(cap_call_handle_t, errno_t, sysarg_t, sysarg_t,
     sysarg_t, sysarg_t, sysarg_t);
 
@@ -212,8 +212,8 @@
  */
 
-extern errno_t async_forward_fast(cap_handle_t, async_exch_t *, sysarg_t, sysarg_t,
-    sysarg_t, unsigned int);
-extern errno_t async_forward_slow(cap_handle_t, async_exch_t *, sysarg_t, sysarg_t,
-    sysarg_t, sysarg_t, sysarg_t, sysarg_t, unsigned int);
+extern errno_t async_forward_fast(cap_call_handle_t, async_exch_t *, sysarg_t,
+    sysarg_t, sysarg_t, unsigned int);
+extern errno_t async_forward_slow(cap_call_handle_t, async_exch_t *, sysarg_t,
+    sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t, unsigned int);
 
 /*
@@ -384,10 +384,11 @@
 extern errno_t async_share_in_start(async_exch_t *, size_t, sysarg_t,
     unsigned int *, void **);
-extern bool async_share_in_receive(cap_handle_t *, size_t *);
-extern errno_t async_share_in_finalize(cap_handle_t, void *, unsigned int);
+extern bool async_share_in_receive(cap_call_handle_t *, size_t *);
+extern errno_t async_share_in_finalize(cap_call_handle_t, void *, unsigned int);
 
 extern errno_t async_share_out_start(async_exch_t *, void *, unsigned int);
-extern bool async_share_out_receive(cap_handle_t *, size_t *, unsigned int *);
-extern errno_t async_share_out_finalize(cap_handle_t, void **);
+extern bool async_share_out_receive(cap_call_handle_t *, size_t *,
+    unsigned int *);
+extern errno_t async_share_out_finalize(cap_call_handle_t, void **);
 
 /*
@@ -423,7 +424,9 @@
 extern aid_t async_data_read(async_exch_t *, void *, size_t, ipc_call_t *);
 extern errno_t async_data_read_start(async_exch_t *, void *, size_t);
-extern bool async_data_read_receive(cap_handle_t *, size_t *);
-extern bool async_data_read_receive_call(cap_handle_t *, ipc_call_t *, size_t *);
-extern errno_t async_data_read_finalize(cap_handle_t, const void *, size_t);
+extern bool async_data_read_receive(cap_call_handle_t *, size_t *);
+extern bool async_data_read_receive_call(cap_call_handle_t *, ipc_call_t *,
+    size_t *);
+extern errno_t async_data_read_finalize(cap_call_handle_t, const void *,
+    size_t);
 
 extern errno_t async_data_read_forward_fast(async_exch_t *, sysarg_t, sysarg_t,
@@ -462,7 +465,8 @@
 
 extern errno_t async_data_write_start(async_exch_t *, const void *, size_t);
-extern bool async_data_write_receive(cap_handle_t *, size_t *);
-extern bool async_data_write_receive_call(cap_handle_t *, ipc_call_t *, size_t *);
-extern errno_t async_data_write_finalize(cap_handle_t, void *, size_t);
+extern bool async_data_write_receive(cap_call_handle_t *, size_t *);
+extern bool async_data_write_receive_call(cap_call_handle_t *, ipc_call_t *,
+    size_t *);
+extern errno_t async_data_write_finalize(cap_call_handle_t, void *, size_t);
 
 extern errno_t async_data_write_accept(void **, const bool, const size_t,
@@ -478,7 +482,7 @@
 extern errno_t async_state_change_start(async_exch_t *, sysarg_t, sysarg_t,
     sysarg_t, async_exch_t *);
-extern bool async_state_change_receive(cap_handle_t *, sysarg_t *, sysarg_t *,
-    sysarg_t *);
-extern errno_t async_state_change_finalize(cap_handle_t, async_exch_t *);
+extern bool async_state_change_receive(cap_call_handle_t *, sysarg_t *,
+    sysarg_t *, sysarg_t *);
+extern errno_t async_state_change_finalize(cap_call_handle_t, async_exch_t *);
 
 extern void *async_remote_state_acquire(async_sess_t *);
Index: uspace/lib/c/include/ipc/common.h
===================================================================
--- uspace/lib/c/include/ipc/common.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/c/include/ipc/common.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -52,8 +52,8 @@
 	unsigned flags;
 	struct async_call *label;
-	cap_handle_t cap_handle;
+	cap_call_handle_t cap_handle;
 } ipc_call_t;
 
-typedef cap_handle_t ipc_callid_t;
+typedef cap_call_handle_t ipc_callid_t;
 
 extern futex_t async_futex;
Index: uspace/lib/c/include/ipc/ipc.h
===================================================================
--- uspace/lib/c/include/ipc/ipc.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/c/include/ipc/ipc.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -78,7 +78,7 @@
 	    (arg5))
 
-extern errno_t ipc_answer_fast(cap_handle_t, errno_t, sysarg_t, sysarg_t,
+extern errno_t ipc_answer_fast(cap_call_handle_t, errno_t, sysarg_t, sysarg_t,
     sysarg_t, sysarg_t);
-extern errno_t ipc_answer_slow(cap_handle_t, errno_t, sysarg_t, sysarg_t,
+extern errno_t ipc_answer_slow(cap_call_handle_t, errno_t, sysarg_t, sysarg_t,
     sysarg_t, sysarg_t, sysarg_t);
 
@@ -110,17 +110,17 @@
 	    (arg4), (arg5), (private), (callback))
 
-extern void ipc_call_async_fast(cap_handle_t, sysarg_t, sysarg_t, sysarg_t,
-    sysarg_t, void *, ipc_async_callback_t);
-extern void ipc_call_async_slow(cap_handle_t, sysarg_t, sysarg_t, sysarg_t,
-    sysarg_t, sysarg_t, sysarg_t, void *, ipc_async_callback_t);
+extern void ipc_call_async_fast(cap_phone_handle_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t, void *, ipc_async_callback_t);
+extern void ipc_call_async_slow(cap_phone_handle_t, sysarg_t, sysarg_t,
+    sysarg_t, sysarg_t, sysarg_t, sysarg_t, void *, ipc_async_callback_t);
 
-extern errno_t ipc_hangup(cap_handle_t);
+extern errno_t ipc_hangup(cap_phone_handle_t);
 
-extern errno_t ipc_forward_fast(cap_handle_t, cap_handle_t, sysarg_t, sysarg_t,
-    sysarg_t, unsigned int);
-extern errno_t ipc_forward_slow(cap_handle_t, cap_handle_t, sysarg_t, sysarg_t,
-    sysarg_t, sysarg_t, sysarg_t, sysarg_t, unsigned int);
+extern errno_t ipc_forward_fast(cap_call_handle_t, cap_phone_handle_t, sysarg_t,
+    sysarg_t, sysarg_t, unsigned int);
+extern errno_t ipc_forward_slow(cap_call_handle_t, cap_phone_handle_t, sysarg_t,
+    sysarg_t, sysarg_t, sysarg_t, sysarg_t, sysarg_t, unsigned int);
 
-extern errno_t ipc_connect_kbox(task_id_t, cap_handle_t *);
+extern errno_t ipc_connect_kbox(task_id_t, cap_phone_handle_t *);
 
 #endif
Index: uspace/lib/c/include/ipc/irq.h
===================================================================
--- uspace/lib/c/include/ipc/irq.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/c/include/ipc/irq.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -40,6 +40,7 @@
 #include <abi/cap.h>
 
-extern errno_t ipc_irq_subscribe(int, sysarg_t, const irq_code_t *, cap_handle_t *);
-extern errno_t ipc_irq_unsubscribe(cap_handle_t);
+extern errno_t ipc_irq_subscribe(int, sysarg_t, const irq_code_t *,
+    cap_irq_handle_t *);
+extern errno_t ipc_irq_unsubscribe(cap_irq_handle_t);
 
 #endif
Index: uspace/lib/drv/generic/interrupt.c
===================================================================
--- uspace/lib/drv/generic/interrupt.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/drv/generic/interrupt.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -45,5 +45,5 @@
 errno_t register_interrupt_handler(ddf_dev_t *dev, int irq,
     interrupt_handler_t *handler, const irq_code_t *irq_code,
-    cap_handle_t *handle)
+    cap_irq_handle_t *handle)
 {
 	return async_irq_subscribe(irq, (async_notification_handler_t) handler,
@@ -51,7 +51,7 @@
 }
 
-errno_t unregister_interrupt_handler(ddf_dev_t *dev, cap_handle_t cap)
+errno_t unregister_interrupt_handler(ddf_dev_t *dev, cap_irq_handle_t handle)
 {
-	return async_irq_unsubscribe(cap);
+	return async_irq_unsubscribe(handle);
 }
 
Index: uspace/lib/drv/include/ddf/interrupt.h
===================================================================
--- uspace/lib/drv/include/ddf/interrupt.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/drv/include/ddf/interrupt.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -51,6 +51,6 @@
 
 extern errno_t register_interrupt_handler(ddf_dev_t *, int, interrupt_handler_t *,
-    const irq_code_t *, cap_handle_t *);
-extern errno_t unregister_interrupt_handler(ddf_dev_t *, cap_handle_t);
+    const irq_code_t *, cap_irq_handle_t *);
+extern errno_t unregister_interrupt_handler(ddf_dev_t *, cap_irq_handle_t);
 
 #endif
Index: uspace/lib/hound/include/hound/protocol.h
===================================================================
--- uspace/lib/hound/include/hound/protocol.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/hound/include/hound/protocol.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -56,5 +56,5 @@
 
 typedef async_sess_t hound_sess_t;
-typedef intptr_t hound_context_id_t;
+typedef cap_call_handle_t hound_context_id_t;
 
 hound_sess_t *hound_service_connect(const char *service);
Index: uspace/lib/hound/src/protocol.c
===================================================================
--- uspace/lib/hound/src/protocol.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/hound/src/protocol.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -153,10 +153,11 @@
  * @return Error code.
  */
-errno_t hound_service_unregister_context(hound_sess_t *sess, hound_context_id_t id)
+errno_t hound_service_unregister_context(hound_sess_t *sess,
+    hound_context_id_t id)
 {
 	assert(sess);
 	async_exch_t *exch = async_exchange_begin(sess);
-	const errno_t ret =
-	    async_req_1_0(exch, IPC_M_HOUND_CONTEXT_UNREGISTER, id);
+	const errno_t ret = async_req_1_0(exch, IPC_M_HOUND_CONTEXT_UNREGISTER,
+	    CAP_HANDLE_RAW(id));
 	async_exchange_end(exch);
 	return ret;
@@ -312,6 +313,6 @@
 		.format = format.sample_format,
 	}};
-	return async_req_4_0(exch, IPC_M_HOUND_STREAM_ENTER, id, flags,
-	    c.arg, bsize);
+	return async_req_4_0(exch, IPC_M_HOUND_STREAM_ENTER, CAP_HANDLE_RAW(id),
+	    flags, c.arg, bsize);
 }
 
@@ -427,5 +428,5 @@
 				async_answer_0(callid, ret);
 			} else {
-				async_answer_1(callid, EOK, id);
+				async_answer_1(callid, EOK, CAP_HANDLE_RAW(id));
 			}
 			break;
@@ -438,5 +439,5 @@
 
 			/* get id, 1st param */
-			id = IPC_GET_ARG1(call);
+			id = (cap_handle_t) IPC_GET_ARG1(call);
 			ret = server_iface->rem_context(server_iface->server,
 			    id);
@@ -564,5 +565,5 @@
 
 			/* get parameters */
-			id = IPC_GET_ARG1(call);
+			id = (cap_handle_t) IPC_GET_ARG1(call);
 			flags = IPC_GET_ARG2(call);
 			const format_convert_t c = {.arg = IPC_GET_ARG3(call)};
Index: uspace/lib/usbhost/include/usb/host/hcd.h
===================================================================
--- uspace/lib/usbhost/include/usb/host/hcd.h	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/usbhost/include/usb/host/hcd.h	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -58,6 +58,6 @@
 	ddf_fun_t *ctl_fun;
 
-	/* Result of enabling HW IRQs */
-	int irq_cap;
+	/* IRQ capability handle of the subscribed IRQ code */
+	cap_irq_handle_t irq_handle;
 
 	/** Interrupt replacement fibril */
Index: uspace/lib/usbhost/src/hcd.c
===================================================================
--- uspace/lib/usbhost/src/hcd.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/lib/usbhost/src/hcd.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -149,12 +149,12 @@
  * If this method fails, a polling fibril is started instead.
  *
- * @param[in] hcd Host controller device.
- * @param[in] hw_res Resources to be used.
- *
- * @return IRQ capability handle on success.
- * @return Negative error code.
+ * @param[in]  hcd         Host controller device.
+ * @param[in]  hw_res      Resources to be used.
+ * @param[out] irq_handle  Storage for the returned IRQ handle
+ *
+ * @return Error code.
  */
 static errno_t hcd_ddf_setup_interrupts(hc_device_t *hcd,
-    const hw_res_list_parsed_t *hw_res)
+    const hw_res_list_parsed_t *hw_res, cap_irq_handle_t *irq_handle)
 {
 	assert(hcd);
@@ -169,17 +169,17 @@
 	if (ret != EOK) {
 		usb_log_error("Failed to generate IRQ code: %s.",
-		    str_error(irq));
-		return irq;
+		    str_error(ret));
+		return ret;
 	}
 
 	/* Register handler to avoid interrupt lockup */
-	int irq_cap;
+	cap_irq_handle_t ihandle;
 	ret = register_interrupt_handler(hcd->ddf_dev, irq, irq_handler,
-	    &irq_code, &irq_cap);
+	    &irq_code, &ihandle);
 	irq_code_clean(&irq_code);
 	if (ret != EOK) {
 		usb_log_error("Failed to register interrupt handler: %s.",
-		    str_error(irq_cap));
-		return irq_cap;
+		    str_error(ret));
+		return ret;
 	}
 
@@ -189,8 +189,10 @@
 		usb_log_error("Failed to enable interrupts: %s.",
 		    str_error(ret));
-		unregister_interrupt_handler(hcd->ddf_dev, irq_cap);
+		unregister_interrupt_handler(hcd->ddf_dev, ihandle);
 		return ret;
 	}
-	return irq_cap;
+
+	*irq_handle = ihandle;
+	return EOK;
 }
 
@@ -245,6 +247,8 @@
 
 	/* Setup interrupts  */
-	hcd->irq_cap = hcd_ddf_setup_interrupts(hcd, &hw_res);
-	if (hcd->irq_cap >= 0) {
+	hcd->irq_handle = CAP_NIL;
+	errno_t irqerr = hcd_ddf_setup_interrupts(hcd, &hw_res,
+	    &hcd->irq_handle);
+	if (irqerr == EOK) {
 		usb_log_debug("Hw interrupts enabled.");
 	}
@@ -270,5 +274,5 @@
 
 	/* Need working irq replacement to setup root hub */
-	if (hcd->irq_cap < 0 && ops->status) {
+	if (irqerr != EOK && ops->status) {
 		hcd->polling_fibril = fibril_create(interrupt_polling, hcd->bus);
 		if (!hcd->polling_fibril) {
@@ -279,5 +283,5 @@
 		fibril_add_ready(hcd->polling_fibril);
 		usb_log_warning("Failed to enable interrupts: %s."
-		    " Falling back to polling.", str_error(hcd->irq_cap));
+		    " Falling back to polling.", str_error(irqerr));
 	}
 
@@ -305,5 +309,5 @@
 		hc_driver->stop(hcd);
 err_irq:
-	unregister_interrupt_handler(device, hcd->irq_cap);
+	unregister_interrupt_handler(device, hcd->irq_handle);
 	if (hc_driver->hc_remove)
 		hc_driver->hc_remove(hcd);
@@ -324,5 +328,5 @@
 			return err;
 
-	unregister_interrupt_handler(dev, hcd->irq_cap);
+	unregister_interrupt_handler(dev, hcd->irq_handle);
 
 	if (hc_driver->hc_remove)
Index: uspace/srv/audio/hound/iface.c
===================================================================
--- uspace/srv/audio/hound/iface.c	(revision 874381a54fd7ce729565b9d2ea3837ab1bcd4b5b)
+++ uspace/srv/audio/hound/iface.c	(revision eadaeae8dacc68cf558028f23cc96b90a08b7361)
@@ -72,5 +72,5 @@
 	if (ret == EOK) {
 		hound_ctx_destroy(ctx);
-		log_info("%s: %p, %#" PRIxn, __FUNCTION__, server, id);
+		log_info("%s: %p, %p", __FUNCTION__, server, id);
 	}
 	return ret;
@@ -116,6 +116,6 @@
 	assert(server);
 
-	log_verbose("%s: %p, %" PRIxn " %x ch:%u r:%u f:%s", __FUNCTION__,
-	    server, id, flags, format.channels, format.sampling_rate,
+	log_verbose("%s: %p, %p %x ch:%u r:%u f:%s", __FUNCTION__, server, id,
+	    flags, format.channels, format.sampling_rate,
 	    pcm_sample_format_str(format.sample_format));
 	hound_ctx_t *ctx = hound_get_ctx_by_id(server, id);