Index: uspace/drv/audio/hdaudio/hdaudio.c
===================================================================
--- uspace/drv/audio/hdaudio/hdaudio.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/audio/hdaudio/hdaudio.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -263,8 +263,8 @@
 	}
 
-	int irq_cap = register_interrupt_handler(dev, res.irqs.irqs[0],
-	    hdaudio_interrupt, &irq_code);
-	if (irq_cap < 0) {
-		rc = irq_cap;
+	int irq_cap;
+	rc = register_interrupt_handler(dev, res.irqs.irqs[0],
+	    hdaudio_interrupt, &irq_code, &irq_cap);
+	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed registering interrupt handler. (%d)",
 		    rc);
Index: uspace/drv/audio/sb16/main.c
===================================================================
--- uspace/drv/audio/sb16/main.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/audio/sb16/main.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -123,8 +123,7 @@
 	};
 
-	irq_cap = register_interrupt_handler(device, irq, irq_handler,
-	    &irq_code);
-	if (irq_cap < 0) {
-		rc = irq_cap;
+	rc = register_interrupt_handler(device, irq, irq_handler,
+	    &irq_code, &irq_cap);
+	if (rc != EOK) {
 		ddf_log_error("Failed to register irq handler: %s.",
 		    str_error(rc));
Index: uspace/drv/block/ahci/ahci.c
===================================================================
--- uspace/drv/block/ahci/ahci.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/block/ahci/ahci.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -1184,12 +1184,13 @@
 	ct.ranges = ahci_ranges;
 	
-	int irq_cap = register_interrupt_handler(dev,
-	    hw_res_parsed.irqs.irqs[0], ahci_interrupt, &ct);
-	if (irq_cap < 0) {
+	int irq_cap;
+	int rc = register_interrupt_handler(dev,
+	    hw_res_parsed.irqs.irqs[0], ahci_interrupt, &ct, &irq_cap);
+	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed registering interrupt handler.");
 		goto error_register_interrupt_handler;
 	}
 	
-	int rc = hw_res_enable_interrupt(ahci->parent_sess,
+	rc = hw_res_enable_interrupt(ahci->parent_sess,
 	    hw_res_parsed.irqs.irqs[0]);
 	if (rc != EOK) {
Index: uspace/drv/block/ddisk/ddisk.c
===================================================================
--- uspace/drv/block/ddisk/ddisk.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/block/ddisk/ddisk.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -503,8 +503,7 @@
 	ddisk_irq_commands[0].addr = (void *) &res_phys->status;
 	ddisk_irq_commands[3].addr = (void *) &res_phys->command;
-	ddisk->irq_cap = register_interrupt_handler(dev, ddisk->ddisk_res.irq,
-	    ddisk_irq_handler, &ddisk_irq_code);
-	if (ddisk->irq_cap < 0) {
-		rc = ddisk->irq_cap;
+	rc = register_interrupt_handler(dev, ddisk->ddisk_res.irq,
+	    ddisk_irq_handler, &ddisk_irq_code, &ddisk->irq_cap);
+	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed to register interrupt handler.");
 		goto error;
Index: uspace/drv/bus/adb/cuda_adb/cuda_adb.c
===================================================================
--- uspace/drv/bus/adb/cuda_adb/cuda_adb.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/bus/adb/cuda_adb/cuda_adb.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -252,5 +252,5 @@
 	cuda_irq_code.cmds[0].addr = (void *) &((cuda_regs_t *)
 	    cuda->phys_base)->ifr;
-	async_irq_subscribe(10, cuda_irq_handler, cuda, &cuda_irq_code);
+	async_irq_subscribe(10, cuda_irq_handler, cuda, &cuda_irq_code, NULL);
 
 	/* Enable SR interrupt. */
Index: uspace/drv/char/i8042/i8042.c
===================================================================
--- uspace/drv/char/i8042/i8042.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/char/i8042/i8042.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -281,8 +281,8 @@
 	};
 	
-	const int irq_kbd_cap = register_interrupt_handler(ddf_dev, irq_kbd,
-	    i8042_irq_handler, &irq_code);
-	if (irq_kbd_cap < 0) {
-		rc = irq_kbd_cap;
+	int irq_kbd_cap;
+	rc = register_interrupt_handler(ddf_dev, irq_kbd,
+	    i8042_irq_handler, &irq_code, &irq_kbd_cap);
+	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed set handler for kbd: %s.",
 		    ddf_dev_get_name(ddf_dev));
@@ -290,8 +290,8 @@
 	}
 	
-	const int irq_mouse_cap = register_interrupt_handler(ddf_dev, irq_mouse,
-	    i8042_irq_handler, &irq_code);
-	if (irq_mouse_cap < 0) {
-		rc = irq_mouse_cap;
+	int irq_mouse_cap;
+	rc = register_interrupt_handler(ddf_dev, irq_mouse,
+	    i8042_irq_handler, &irq_code, &irq_mouse_cap);
+	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed set handler for mouse: %s.",
 		    ddf_dev_get_name(ddf_dev));
Index: uspace/drv/char/msim-con/msim-con.c
===================================================================
--- uspace/drv/char/msim-con/msim-con.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/char/msim-con/msim-con.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -125,5 +125,5 @@
 	con->irq_code.cmds = msim_cmds;
 
-	async_irq_subscribe(res->irq, msim_irq_handler, con, &con->irq_code);
+	async_irq_subscribe(res->irq, msim_irq_handler, con, &con->irq_code, NULL);
 	subscribed = true;
 
Index: uspace/drv/char/ns8250/ns8250.c
===================================================================
--- uspace/drv/char/ns8250/ns8250.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/char/ns8250/ns8250.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -802,8 +802,9 @@
  * @param ns		Serial port device
  */
-static inline int ns8250_register_interrupt_handler(ns8250_t *ns)
+static inline int ns8250_register_interrupt_handler(ns8250_t *ns,
+    cap_handle_t *handle)
 {
 	return register_interrupt_handler(ns->dev, ns->irq,
-	    ns8250_interrupt_handler, NULL);
+	    ns8250_interrupt_handler, NULL, handle);
 }
 
@@ -874,6 +875,6 @@
 	
 	/* Register interrupt handler. */
-	ns->irq_cap = ns8250_register_interrupt_handler(ns);
-	if (ns->irq_cap < 0) {
+	rc = ns8250_register_interrupt_handler(ns, &ns->irq_cap);
+	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed to register interrupt handler.");
 		rc = EADDRNOTAVAIL;
Index: uspace/drv/char/pl050/pl050.c
===================================================================
--- uspace/drv/char/pl050/pl050.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/char/pl050/pl050.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -213,8 +213,8 @@
 	pl050->regs = regs;
 
-	const int irq_cap = register_interrupt_handler(pl050->dev,
-	    res.irqs.irqs[0], pl050_interrupt, &pl050_irq_code);
-	if (irq_cap < 0) {
-		rc = irq_cap;
+	int irq_cap;
+	rc = register_interrupt_handler(pl050->dev,
+	    res.irqs.irqs[0], pl050_interrupt, &pl050_irq_code, &irq_cap);
+	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed registering interrupt handler. (%d)",
 		    rc);
Index: uspace/drv/nic/e1k/e1k.c
===================================================================
--- uspace/drv/nic/e1k/e1k.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/nic/e1k/e1k.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -1259,9 +1259,10 @@
  * @param nic Driver data
  *
- * @return IRQ capability handle if the handler was registered
+ * @param[out] handle  IRQ capability handle if the handler was registered
+ *
  * @return Negative error code otherwise
  *
  */
-inline static int e1000_register_int_handler(nic_t *nic)
+inline static int e1000_register_int_handler(nic_t *nic, cap_handle_t *handle)
 {
 	e1000_t *e1000 = DRIVER_DATA_NIC(nic);
@@ -1274,9 +1275,9 @@
 	e1000_irq_code.cmds[2].addr = e1000->reg_base_phys + E1000_IMC;
 	
-	int cap = register_interrupt_handler(nic_get_ddf_dev(nic), e1000->irq,
-	    e1000_interrupt_handler, &e1000_irq_code);
+	int rc = register_interrupt_handler(nic_get_ddf_dev(nic), e1000->irq,
+	    e1000_interrupt_handler, &e1000_irq_code, handle);
 	
 	fibril_mutex_unlock(&irq_reg_mutex);
-	return cap;
+	return rc;
 }
 
@@ -2164,7 +2165,7 @@
 	ddf_fun_set_ops(fun, &e1000_dev_ops);
 	
-	int irq_cap = e1000_register_int_handler(nic);
-	if (irq_cap < 0) {
-		rc = irq_cap;
+	int irq_cap;
+	rc = e1000_register_int_handler(nic, &irq_cap);
+	if (rc != EOK) {
 		goto err_fun_create;
 	}
Index: uspace/drv/nic/ne2k/ne2k.c
===================================================================
--- uspace/drv/nic/ne2k/ne2k.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/nic/ne2k/ne2k.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -124,5 +124,5 @@
 static void ne2k_interrupt_handler(ipc_call_t *, ddf_dev_t *);
 
-static int ne2k_register_interrupt(nic_t *nic_data)
+static int ne2k_register_interrupt(nic_t *nic_data, cap_handle_t *handle)
 {
 	ne2k_t *ne2k = (ne2k_t *) nic_get_specific(nic_data);
@@ -160,7 +160,6 @@
 	}
 
-	int irq_cap = register_interrupt_handler(nic_get_ddf_dev(nic_data),
-		ne2k->irq, ne2k_interrupt_handler, &ne2k->code);
-	return irq_cap;
+	return register_interrupt_handler(nic_get_ddf_dev(nic_data),
+		ne2k->irq, ne2k_interrupt_handler, &ne2k->code, handle);
 }
 
@@ -228,6 +227,5 @@
 	ne2k->probed = true;
 	
-	int irq_cap = ne2k_register_interrupt(nic_data);
-	if (irq_cap < 0)
+	if (ne2k_register_interrupt(nic_data, NULL) != EOK)
 		return EINVAL;
 	
Index: uspace/drv/nic/rtl8139/driver.c
===================================================================
--- uspace/drv/nic/rtl8139/driver.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/nic/rtl8139/driver.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -842,8 +842,9 @@
  *  @param nic_data  The driver data
  *
- *  @return IRQ capability handle if the handler was registered.
+ *  @param[out] handle  IRQ capability handle if the handler was registered.
+ *
  *  @return Negative error code otherwise.
  */
-inline static int rtl8139_register_int_handler(nic_t *nic_data)
+inline static int rtl8139_register_int_handler(nic_t *nic_data, cap_handle_t *handle)
 {
 	rtl8139_t *rtl8139 = nic_get_specific(nic_data);
@@ -856,10 +857,10 @@
 	rtl8139_irq_code.cmds[2].addr = rtl8139->io_addr + ISR;
 	rtl8139_irq_code.cmds[3].addr = rtl8139->io_addr + IMR;
-	int cap = register_interrupt_handler(nic_get_ddf_dev(nic_data),
-	    rtl8139->irq, rtl8139_interrupt_handler, &rtl8139_irq_code);
+	int rc = register_interrupt_handler(nic_get_ddf_dev(nic_data),
+	    rtl8139->irq, rtl8139_interrupt_handler, &rtl8139_irq_code, handle);
 
 	RTL8139_IRQ_STRUCT_UNLOCK();
 
-	return cap;
+	return rc;
 }
 
@@ -1287,7 +1288,7 @@
 
 	/* Register interrupt handler */
-	int irq_cap = rtl8139_register_int_handler(nic_data);
-	if (irq_cap < 0) {
-		rc = irq_cap;
+	int irq_cap;
+	rc = rtl8139_register_int_handler(nic_data, &irq_cap);
+	if (rc != EOK) {
 		goto err_pio;
 	}
Index: uspace/drv/nic/rtl8169/driver.c
===================================================================
--- uspace/drv/nic/rtl8169/driver.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/drv/nic/rtl8169/driver.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -73,5 +73,5 @@
 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 int rtl8169_register_int_handler(nic_t *nic_data);
+static inline int rtl8169_register_int_handler(nic_t *nic_data, cap_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);
@@ -359,5 +359,5 @@
 }
 
-inline static int rtl8169_register_int_handler(nic_t *nic_data)
+inline static int rtl8169_register_int_handler(nic_t *nic_data, cap_handle_t *handle)
 {
 	rtl8169_t *rtl8169 = nic_get_specific(nic_data);
@@ -367,8 +367,8 @@
 	rtl8169_irq_code.cmds[2].addr = rtl8169->regs + ISR;
 	rtl8169_irq_code.cmds[3].addr = rtl8169->regs + IMR;
-	int irq_cap = register_interrupt_handler(nic_get_ddf_dev(nic_data),
-	    rtl8169->irq, rtl8169_irq_handler, &rtl8169_irq_code);
-
-	return irq_cap;
+	int rc = register_interrupt_handler(nic_get_ddf_dev(nic_data),
+	    rtl8169->irq, rtl8169_irq_handler, &rtl8169_irq_code, handle);
+
+	return rc;
 }
 
@@ -427,7 +427,7 @@
 		goto err_pio;
 
-	int irq_cap = rtl8169_register_int_handler(nic_data);
-	if (irq_cap < 0) {
-		rc = irq_cap;
+	int irq_cap;
+	rc = rtl8169_register_int_handler(nic_data, &irq_cap);
+	if (rc != EOK) {
 		ddf_msg(LVL_ERROR, "Failed to register IRQ handler (%d)", rc);
 		goto err_irq;
Index: uspace/lib/c/generic/async.c
===================================================================
--- uspace/lib/c/generic/async.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/lib/c/generic/async.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -1051,10 +1051,11 @@
  * @param ucode   Top-half pseudocode handler.
  *
- * @return IRQ capability handle on success.
+ * @param[out] handle  IRQ capability handle on success.
+ *
  * @return Negative error code.
  *
  */
 int async_irq_subscribe(int inr, async_notification_handler_t handler,
-    void *data, const irq_code_t *ucode)
+    void *data, const irq_code_t *ucode, cap_handle_t *handle)
 {
 	notification_t *notification =
@@ -1078,8 +1079,8 @@
 	cap_handle_t cap;
 	int rc = ipc_irq_subscribe(inr, imethod, ucode, &cap);
-	if (rc != EOK) {
-		return rc;
-	}
-	return cap;
+	if (rc == EOK && handle != NULL) {
+		*handle = cap;
+	}
+	return rc;
 }
 
Index: uspace/lib/c/include/async.h
===================================================================
--- uspace/lib/c/include/async.h	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/lib/c/include/async.h	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -169,5 +169,5 @@
 
 extern int async_irq_subscribe(int, async_notification_handler_t, void *,
-    const irq_code_t *);
+    const irq_code_t *, cap_handle_t *);
 extern int async_irq_unsubscribe(int);
 
Index: uspace/lib/drv/generic/interrupt.c
===================================================================
--- uspace/lib/drv/generic/interrupt.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/lib/drv/generic/interrupt.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -44,8 +44,9 @@
 
 int register_interrupt_handler(ddf_dev_t *dev, int irq,
-    interrupt_handler_t *handler, const irq_code_t *irq_code)
+    interrupt_handler_t *handler, const irq_code_t *irq_code,
+    cap_handle_t *handle)
 {
 	return async_irq_subscribe(irq, (async_notification_handler_t) handler,
-	    dev, irq_code);
+	    dev, irq_code, handle);
 }
 
Index: uspace/lib/drv/include/ddf/interrupt.h
===================================================================
--- uspace/lib/drv/include/ddf/interrupt.h	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/lib/drv/include/ddf/interrupt.h	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -51,5 +51,5 @@
 
 extern int register_interrupt_handler(ddf_dev_t *, int, interrupt_handler_t *,
-    const irq_code_t *);
+    const irq_code_t *, cap_handle_t *);
 extern int unregister_interrupt_handler(ddf_dev_t *, int);
 
Index: uspace/lib/usbhost/include/usb/host/ddf_helpers.h
===================================================================
--- uspace/lib/usbhost/include/usb/host/ddf_helpers.h	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/lib/usbhost/include/usb/host/ddf_helpers.h	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -75,5 +75,6 @@
     const hw_res_list_parsed_t *hw_res,
     interrupt_handler_t handler,
-    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *));
+    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *),
+    cap_handle_t *handle);
 void ddf_hcd_gen_irq_handler(ipc_call_t *call, ddf_dev_t *dev);
 
Index: uspace/lib/usbhost/src/ddf_helpers.c
===================================================================
--- uspace/lib/usbhost/src/ddf_helpers.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/lib/usbhost/src/ddf_helpers.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -742,11 +742,13 @@
  * @param[in] gen_irq_code IRQ code generator.
  *
- * @return IRQ capability handle on success.
- * @return Negative error code.
+ * @param[out] handle  IRQ capability handle on success.
+ *
+ * @return Error code.
  */
 int hcd_ddf_setup_interrupts(ddf_dev_t *device,
     const hw_res_list_parsed_t *hw_res,
     interrupt_handler_t handler,
-    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *hw_res))
+    int (*gen_irq_code)(irq_code_t *, const hw_res_list_parsed_t *hw_res),
+    cap_handle_t *handle)
 {
 
@@ -765,22 +767,21 @@
 
 	/* Register handler to avoid interrupt lockup */
-	const int irq_cap = register_interrupt_handler(device, irq, handler,
-	    &irq_code);
+	int ret = register_interrupt_handler(device, irq, handler,
+	    &irq_code, handle);
 	irq_code_clean(&irq_code);
-	if (irq_cap < 0) {
-		usb_log_error("Failed to register interrupt handler: %s.\n",
-		    str_error(irq_cap));
-		return irq_cap;
-	}
-
-	/* Enable interrupts */
-	int ret = hcd_ddf_enable_interrupt(device, irq);
 	if (ret != EOK) {
 		usb_log_error("Failed to register interrupt handler: %s.\n",
 		    str_error(ret));
-		unregister_interrupt_handler(device, irq_cap);
-		return ret;
-	}
-	return irq_cap;
+		return ret;
+	}
+
+	/* Enable interrupts */
+	ret = hcd_ddf_enable_interrupt(device, irq);
+	if (ret != EOK) {
+		usb_log_error("Failed to register interrupt handler: %s.\n",
+		    str_error(ret));
+		unregister_interrupt_handler(device, *handle);
+	}
+	return ret;
 }
 
@@ -876,17 +877,19 @@
 	interrupt_handler_t *irq_handler =
 	    driver->irq_handler ? driver->irq_handler : ddf_hcd_gen_irq_handler;
-	const int irq_cap = hcd_ddf_setup_interrupts(device, &hw_res,
-	    irq_handler, driver->irq_code_gen);
-	bool irqs_enabled = !(irq_cap < 0);
+	int irq_cap;
+	ret = hcd_ddf_setup_interrupts(device, &hw_res,
+	    irq_handler, driver->irq_code_gen, &irq_cap);
+	bool irqs_enabled = (ret == EOK);
 	if (irqs_enabled) {
 		usb_log_debug("Hw interrupts enabled.\n");
 	}
 
-	if (driver->claim)
+	if (driver->claim) {
 		ret = driver->claim(device);
-	if (ret != EOK) {
-		usb_log_error("Failed to claim `%s' for driver `%s'",
-		    ddf_dev_get_name(device), driver->name);
-		return ret;
+		if (ret != EOK) {
+			usb_log_error("Failed to claim `%s' for driver `%s'",
+			    ddf_dev_get_name(device), driver->name);
+			return ret;
+		}
 	}
 
Index: uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c
===================================================================
--- uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/srv/hid/s3c24xx_ts/s3c24xx_ts.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -137,5 +137,5 @@
 	    (void *) ts->paddr, inr);
 
-	async_irq_subscribe(inr, s3c24xx_ts_irq_handler, NULL, &ts_irq_code);
+	async_irq_subscribe(inr, s3c24xx_ts_irq_handler, NULL, &ts_irq_code, NULL);
 
 	s3c24xx_ts_wait_for_int_mode(ts, updn_down);
Index: uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c
===================================================================
--- uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c	(revision 9233e9d118684a5593c031918cef402e75d25718)
+++ uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c	(revision 071a1ddbcc6bb2b9c6f3c1a3acc865f1f23b5fe0)
@@ -173,5 +173,5 @@
 	    (void *) uart->paddr, inr);
 
-	async_irq_subscribe(inr, s3c24xx_uart_irq_handler, NULL, &uart_irq_code);
+	async_irq_subscribe(inr, s3c24xx_uart_irq_handler, NULL, &uart_irq_code, NULL);
 
 	/* Enable FIFO, Tx trigger level: empty, Rx trigger level: 1 byte. */