Index: kernel/genarch/src/drivers/dsrln/dsrlnin.c
===================================================================
--- kernel/genarch/src/drivers/dsrln/dsrlnin.c	(revision f4b153529231867ef6c64403a465d1f66e1016ca)
+++ kernel/genarch/src/drivers/dsrln/dsrlnin.c	(revision a1a83e5e5ddb366d3021bdee2baa08d1a60230fc)
@@ -41,8 +41,4 @@
 #include <ddi/device.h>
 
-static indev_operations_t kbrdin_ops = {
-	.poll = NULL
-};
-
 static irq_ownership_t dsrlnin_claim(irq_t *irq)
 {
@@ -55,27 +51,33 @@
 	dsrlnin_t *dev = instance->dsrlnin;
 	
-	indev_push_character(&instance->kbrdin, pio_read_8(&dev->data));
+	indev_push_character(instance->srlnin, pio_read_8(&dev->data));
 }
 
-indev_t *dsrlnin_init(dsrlnin_t *dev, inr_t inr)
+dsrlnin_instance_t *dsrlnin_init(dsrlnin_t *dev, inr_t inr)
 {
 	dsrlnin_instance_t *instance
 	    = malloc(sizeof(dsrlnin_instance_t), FRAME_ATOMIC);
-	if (!instance)
-		return NULL;
+	if (instance) {
+		instance->dsrlnin = dev;
+		instance->srlnin = NULL;
+		
+		irq_initialize(&instance->irq);
+		instance->irq.devno = device_assign_devno();
+		instance->irq.inr = inr;
+		instance->irq.claim = dsrlnin_claim;
+		instance->irq.handler = dsrlnin_irq_handler;
+		instance->irq.instance = instance;
+	}
 	
-	indev_initialize("dsrlnin", &instance->kbrdin, &kbrdin_ops);
+	return instance;
+}
+
+void dsrlnin_wire(dsrlnin_instance_t *instance, indev_t *srlnin)
+{
+	ASSERT(instance);
+	ASSERT(srlnin);
 	
-	instance->dsrlnin = dev;
-	
-	irq_initialize(&instance->irq);
-	instance->irq.devno = device_assign_devno();
-	instance->irq.inr = inr;
-	instance->irq.claim = dsrlnin_claim;
-	instance->irq.handler = dsrlnin_irq_handler;
-	instance->irq.instance = instance;
+	instance->srlnin = srlnin;
 	irq_register(&instance->irq);
-	
-	return &instance->kbrdin;
 }
 
Index: kernel/genarch/src/drivers/i8042/i8042.c
===================================================================
--- kernel/genarch/src/drivers/i8042/i8042.c	(revision f4b153529231867ef6c64403a465d1f66e1016ca)
+++ kernel/genarch/src/drivers/i8042/i8042.c	(revision a1a83e5e5ddb366d3021bdee2baa08d1a60230fc)
@@ -45,8 +45,4 @@
 #include <ddi/device.h>
 
-static indev_operations_t kbrdin_ops = {
-	.poll = NULL
-};
-
 #define i8042_SET_COMMAND  0x60
 #define i8042_COMMAND      0x69
@@ -75,33 +71,44 @@
 	if (((status = pio_read_8(&dev->status)) & i8042_BUFFER_FULL_MASK)) {
 		uint8_t data = pio_read_8(&dev->data);
-		indev_push_character(&instance->kbrdin, data);
+		indev_push_character(instance->kbrdin, data);
 	}
 }
 
+/**< Clear input buffer. */
+static void i8042_clear_buffer(i8042_t *dev)
+{
+	while (pio_read_8(&dev->status) & i8042_BUFFER_FULL_MASK)
+		(void) pio_read_8(&dev->data);
+}
+
 /** Initialize i8042. */
-indev_t *i8042_init(i8042_t *dev, inr_t inr)
+i8042_instance_t *i8042_init(i8042_t *dev, inr_t inr)
 {
 	i8042_instance_t *instance
 	    = malloc(sizeof(i8042_instance_t), FRAME_ATOMIC);
-	if (!instance)
-		return NULL;
+	if (instance) {
+		instance->i8042 = dev;
+		instance->kbrdin = NULL;
+		
+		irq_initialize(&instance->irq);
+		instance->irq.devno = device_assign_devno();
+		instance->irq.inr = inr;
+		instance->irq.claim = i8042_claim;
+		instance->irq.handler = i8042_irq_handler;
+		instance->irq.instance = instance;
+		
+	}
 	
-	indev_initialize("i8042", &instance->kbrdin, &kbrdin_ops);
+	return instance;
+}
+
+void i8042_wire(i8042_instance_t *instance, indev_t *kbrdin)
+{
+	ASSERT(instance);
+	ASSERT(kbrdin);
 	
-	instance->i8042 = dev;
-	
-	irq_initialize(&instance->irq);
-	instance->irq.devno = device_assign_devno();
-	instance->irq.inr = inr;
-	instance->irq.claim = i8042_claim;
-	instance->irq.handler = i8042_irq_handler;
-	instance->irq.instance = instance;
+	instance->kbrdin = kbrdin;
 	irq_register(&instance->irq);
-	
-	/* Clear input buffer */
-	while (pio_read_8(&dev->status) & i8042_BUFFER_FULL_MASK)
-		(void) pio_read_8(&dev->data);
-	
-	return &instance->kbrdin;
+	i8042_clear_buffer(instance->i8042);
 }
 
@@ -111,7 +118,5 @@
 	interrupts_disable();
 	
-	/* Clear input buffer */
-	while (pio_read_8(&dev->status) & i8042_BUFFER_FULL_MASK)
-		(void) pio_read_8(&dev->data);
+	i8042_clear_buffer(dev);
 	
 	/* Reset CPU */
Index: kernel/genarch/src/drivers/ns16550/ns16550.c
===================================================================
--- kernel/genarch/src/drivers/ns16550/ns16550.c	(revision f4b153529231867ef6c64403a465d1f66e1016ca)
+++ kernel/genarch/src/drivers/ns16550/ns16550.c	(revision a1a83e5e5ddb366d3021bdee2baa08d1a60230fc)
@@ -44,8 +44,4 @@
 #define LSR_DATA_READY  0x01
 
-static indev_operations_t kbrdin_ops = {
-	.poll = NULL
-};
-
 static irq_ownership_t ns16550_claim(irq_t *irq)
 {
@@ -65,7 +61,14 @@
 	
 	if (pio_read_8(&dev->lsr) & LSR_DATA_READY) {
-		uint8_t x = pio_read_8(&dev->rbr);
-		indev_push_character(&instance->kbrdin, x);
+		uint8_t data = pio_read_8(&dev->rbr);
+		indev_push_character(instance->kbrdin, data);
 	}
+}
+
+/**< Clear input buffer. */
+static void ns16550_clear_buffer(ns16550_t *dev)
+{
+	while ((pio_read_8(&dev->lsr) & LSR_DATA_READY))
+		(void) pio_read_8(&dev->rbr);
 }
 
@@ -78,36 +81,41 @@
  * @param cir_arg  First argument to cir.
  *
- * @return Keyboard device pointer or NULL on failure.
+ * @return Keyboard instance or NULL on failure.
  *
  */
-indev_t *ns16550_init(ns16550_t *dev, inr_t inr, cir_t cir, void *cir_arg)
+ns16550_instance_t *ns16550_init(ns16550_t *dev, inr_t inr, cir_t cir, void *cir_arg)
 {
 	ns16550_instance_t *instance
 	    = malloc(sizeof(ns16550_instance_t), FRAME_ATOMIC);
-	if (!instance)
-		return NULL;
+	if (instance) {
+		instance->ns16550 = dev;
+		instance->kbrdin = NULL;
+		
+		irq_initialize(&instance->irq);
+		instance->irq.devno = device_assign_devno();
+		instance->irq.inr = inr;
+		instance->irq.claim = ns16550_claim;
+		instance->irq.handler = ns16550_irq_handler;
+		instance->irq.instance = instance;
+		instance->irq.cir = cir;
+		instance->irq.cir_arg = cir_arg;
+	}
 	
-	indev_initialize("ns16550", &instance->kbrdin, &kbrdin_ops);
+	return instance;
+}
+
+void ns16550_wire(ns16550_instance_t *instance, indev_t *kbrdin)
+{
+	ASSERT(instance);
+	ASSERT(kbrdin);
 	
-	instance->ns16550 = dev;
-	
-	irq_initialize(&instance->irq);
-	instance->irq.devno = device_assign_devno();
-	instance->irq.inr = inr;
-	instance->irq.claim = ns16550_claim;
-	instance->irq.handler = ns16550_irq_handler;
-	instance->irq.instance = instance;
-	instance->irq.cir = cir;
-	instance->irq.cir_arg = cir_arg;
+	instance->kbrdin = kbrdin;
 	irq_register(&instance->irq);
 	
-	while ((pio_read_8(&dev->lsr) & LSR_DATA_READY))
-		(void) pio_read_8(&dev->rbr);
+	ns16550_clear_buffer(instance->ns16550);
 	
 	/* Enable interrupts */
-	pio_write_8(&dev->ier, IER_ERBFI);
-	pio_write_8(&dev->mcr, MCR_OUT2);
-	
-	return &instance->kbrdin;
+	pio_write_8(&instance->ns16550->ier, IER_ERBFI);
+	pio_write_8(&instance->ns16550->mcr, MCR_OUT2);
 }
 
Index: kernel/genarch/src/drivers/via-cuda/cuda.c
===================================================================
--- kernel/genarch/src/drivers/via-cuda/cuda.c	(revision a1a83e5e5ddb366d3021bdee2baa08d1a60230fc)
+++ kernel/genarch/src/drivers/via-cuda/cuda.c	(revision a1a83e5e5ddb366d3021bdee2baa08d1a60230fc)
@@ -0,0 +1,78 @@
+/*
+ * Copyright (c) 2006 Martin Decky
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * - Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * - The name of the author may not be used to endorse or promote products
+ *   derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/** @addtogroup genarch
+ * @{
+ */
+/** @file
+ */
+
+#include <genarch/drivers/via-cuda/cuda.h>
+#include <console/chardev.h>
+#include <ddi/irq.h>
+#include <arch/asm.h>
+#include <mm/slab.h>
+#include <ddi/device.h>
+
+static irq_ownership_t cuda_claim(irq_t *irq)
+{
+	return IRQ_DECLINE;
+}
+
+static void cuda_irq_handler(irq_t *irq)
+{
+}
+
+cuda_instance_t *cuda_init(cuda_t *dev, inr_t inr, cir_t cir, void *cir_arg)
+{
+	cuda_instance_t *instance
+	    = malloc(sizeof(cuda_instance_t), FRAME_ATOMIC);
+	if (instance) {
+		instance->cuda = dev;
+		instance->kbrdin = NULL;
+		
+		irq_initialize(&instance->irq);
+		instance->irq.devno = device_assign_devno();
+		instance->irq.inr = inr;
+		instance->irq.claim = cuda_claim;
+		instance->irq.handler = cuda_irq_handler;
+		instance->irq.instance = instance;
+		instance->irq.cir = cir;
+		instance->irq.cir_arg = cir_arg;
+	}
+	
+	return instance;
+}
+
+void cuda_wire(cuda_instance_t *instance, indev_t *kbrdin)
+{
+}
+
+
+/** @}
+ */
Index: kernel/genarch/src/drivers/z8530/z8530.c
===================================================================
--- kernel/genarch/src/drivers/z8530/z8530.c	(revision f4b153529231867ef6c64403a465d1f66e1016ca)
+++ kernel/genarch/src/drivers/z8530/z8530.c	(revision a1a83e5e5ddb366d3021bdee2baa08d1a60230fc)
@@ -42,8 +42,4 @@
 #include <ddi/device.h>
 
-static indev_operations_t kbrdin_ops = {
-	.poll = NULL
-};
-
 static inline void z8530_write(ioport8_t *ctl, uint8_t reg, uint8_t val)
 {
@@ -83,32 +79,41 @@
 	
 	if (z8530_read(&dev->ctl_a, RR0) & RR0_RCA) {
-		uint8_t x = z8530_read(&dev->ctl_a, RR8);
-		indev_push_character(&instance->kbrdin, x);
+		uint8_t data = z8530_read(&dev->ctl_a, RR8);
+		indev_push_character(instance->kbrdin, data);
 	}
 }
 
 /** Initialize z8530. */
-indev_t *z8530_init(z8530_t *dev, inr_t inr, cir_t cir, void *cir_arg)
+z8530_instance_t *z8530_init(z8530_t *dev, inr_t inr, cir_t cir, void *cir_arg)
 {
 	z8530_instance_t *instance
 	    = malloc(sizeof(z8530_instance_t), FRAME_ATOMIC);
-	if (!instance)
-		return false;
+	if (instance) {
+		instance->z8530 = dev;
+		instance->kbrdin = NULL;
+		
+		irq_initialize(&instance->irq);
+		instance->irq.devno = device_assign_devno();
+		instance->irq.inr = inr;
+		instance->irq.claim = z8530_claim;
+		instance->irq.handler = z8530_irq_handler;
+		instance->irq.instance = instance;
+		instance->irq.cir = cir;
+		instance->irq.cir_arg = cir_arg;
+	}
 	
-	indev_initialize("z8530", &instance->kbrdin, &kbrdin_ops);
+	return instance;
+}
+
+void z8530_wire(z8530_instance_t *instance, indev_t *kbrdin)
+{
+	ASSERT(instance);
+	ASSERT(kbrdin);
 	
-	instance->z8530 = dev;
+	instance->kbrdin = kbrdin;
 	
-	irq_initialize(&instance->irq);
-	instance->irq.devno = device_assign_devno();
-	instance->irq.inr = inr;
-	instance->irq.claim = z8530_claim;
-	instance->irq.handler = z8530_irq_handler;
-	instance->irq.instance = instance;
-	instance->irq.cir = cir;
-	instance->irq.cir_arg = cir_arg;
 	irq_register(&instance->irq);
 	
-	(void) z8530_read(&dev->ctl_a, RR8);
+	(void) z8530_read(&instance->z8530->ctl_a, RR8);
 	
 	/*
@@ -116,16 +121,14 @@
 	 * to set FHC UART interrupt state to idle.
 	 */
-	z8530_write(&dev->ctl_a, WR0, WR0_TX_IP_RST);
+	z8530_write(&instance->z8530->ctl_a, WR0, WR0_TX_IP_RST);
 	
 	/* interrupt on all characters */
-	z8530_write(&dev->ctl_a, WR1, WR1_IARCSC);
+	z8530_write(&instance->z8530->ctl_a, WR1, WR1_IARCSC);
 	
 	/* 8 bits per character and enable receiver */
-	z8530_write(&dev->ctl_a, WR3, WR3_RX8BITSCH | WR3_RX_ENABLE);
+	z8530_write(&instance->z8530->ctl_a, WR3, WR3_RX8BITSCH | WR3_RX_ENABLE);
 	
 	/* Master Interrupt Enable. */
-	z8530_write(&dev->ctl_a, WR9, WR9_MIE);
-	
-	return &instance->kbrdin;
+	z8530_write(&instance->z8530->ctl_a, WR9, WR9_MIE);
 }
 
Index: kernel/genarch/src/kbrd/kbrd.c
===================================================================
--- kernel/genarch/src/kbrd/kbrd.c	(revision f4b153529231867ef6c64403a465d1f66e1016ca)
+++ kernel/genarch/src/kbrd/kbrd.c	(revision a1a83e5e5ddb366d3021bdee2baa08d1a60230fc)
@@ -60,13 +60,7 @@
 #define LOCKED_CAPSLOCK   (1 << 0)
 
-static indev_t kbrdout;
-
-indev_operations_t kbrdout_ops = {
+static indev_operations_t kbrd_raw_ops = {
 	.poll = NULL
 };
-
-SPINLOCK_INITIALIZE(keylock);   /**< keylock protects keyflags and lockflags. */
-static volatile int keyflags;   /**< Tracking of multiple keypresses. */
-static volatile int lockflags;  /**< Tracking of multiple keys lockings. */
 
 /** Process release of key.
@@ -74,23 +68,25 @@
  * @param sc Scancode of the key being released.
  */
-static void key_released(wchar_t sc)
+static void key_released(kbrd_instance_t *instance, wchar_t sc)
 {
-	spinlock_lock(&keylock);
+	spinlock_lock(&instance->keylock);
+	
 	switch (sc) {
 	case SC_LSHIFT:
 	case SC_RSHIFT:
-		keyflags &= ~PRESSED_SHIFT;
+		instance->keyflags &= ~PRESSED_SHIFT;
 		break;
 	case SC_CAPSLOCK:
-		keyflags &= ~PRESSED_CAPSLOCK;
-		if (lockflags & LOCKED_CAPSLOCK)
-			lockflags &= ~LOCKED_CAPSLOCK;
+		instance->keyflags &= ~PRESSED_CAPSLOCK;
+		if (instance->lockflags & LOCKED_CAPSLOCK)
+			instance->lockflags &= ~LOCKED_CAPSLOCK;
 		else
-			lockflags |= LOCKED_CAPSLOCK;
+			instance->lockflags |= LOCKED_CAPSLOCK;
 		break;
 	default:
 		break;
 	}
-	spinlock_unlock(&keylock);
+	
+	spinlock_unlock(&instance->keylock);
 }
 
@@ -99,5 +95,5 @@
  * @param sc Scancode of the key being pressed.
  */
-static void key_pressed(wchar_t sc)
+static void key_pressed(kbrd_instance_t *instance, wchar_t sc)
 {
 	bool letter;
@@ -105,12 +101,13 @@
 	bool capslock;
 	
-	spinlock_lock(&keylock);
+	spinlock_lock(&instance->keylock);
+	
 	switch (sc) {
 	case SC_LSHIFT:
 	case SC_RSHIFT:
-		keyflags |= PRESSED_SHIFT;
+		instance->keyflags |= PRESSED_SHIFT;
 		break;
 	case SC_CAPSLOCK:
-		keyflags |= PRESSED_CAPSLOCK;
+		instance->keyflags |= PRESSED_CAPSLOCK;
 		break;
 	case SC_SCAN_ESCAPE:
@@ -118,7 +115,7 @@
 	default:
 		letter = islower(sc_primary_map[sc]);
-		shift = keyflags & PRESSED_SHIFT;
-		capslock = (keyflags & PRESSED_CAPSLOCK) ||
-		    (lockflags & LOCKED_CAPSLOCK);
+		shift = instance->keyflags & PRESSED_SHIFT;
+		capslock = (instance->keyflags & PRESSED_CAPSLOCK) ||
+		    (instance->lockflags & LOCKED_CAPSLOCK);
 		
 		if ((letter) && (capslock))
@@ -126,18 +123,19 @@
 		
 		if (shift)
-			indev_push_character(stdin, sc_secondary_map[sc]);
+			indev_push_character(instance->sink, sc_secondary_map[sc]);
 		else
-			indev_push_character(stdin, sc_primary_map[sc]);
+			indev_push_character(instance->sink, sc_primary_map[sc]);
 		break;
 	}
-	spinlock_unlock(&keylock);
+	
+	spinlock_unlock(&instance->keylock);
 }
 
 static void kkbrd(void *arg)
 {
-	indev_t *in = (indev_t *) arg;
+	kbrd_instance_t *instance = (kbrd_instance_t *) arg;
 	
 	while (true) {
-		wchar_t sc = _getc(in);
+		wchar_t sc = indev_pop_character(&instance->raw);
 		
 		if (sc == IGNORE_CODE)
@@ -145,20 +143,43 @@
 		
 		if (sc & KEY_RELEASE)
-			key_released((sc ^ KEY_RELEASE) & 0x7f);
+			key_released(instance, (sc ^ KEY_RELEASE) & 0x7f);
 		else
-			key_pressed(sc & 0x7f);
+			key_pressed(instance, sc & 0x7f);
 	}
 }
 
-void kbrd_init(indev_t *devin)
+kbrd_instance_t *kbrd_init(void)
 {
-	indev_initialize("kbrd", &kbrdout, &kbrdout_ops);
-	thread_t *thread
-	    = thread_create(kkbrd, devin, TASK, 0, "kkbrd", false);
+	kbrd_instance_t *instance
+	    = malloc(sizeof(kbrd_instance_t), FRAME_ATOMIC);
+	if (instance) {
+		instance->thread
+			= thread_create(kkbrd, (void *) instance, TASK, 0, "kkbrd", false);
+		
+		if (!instance->thread) {
+			free(instance);
+			return NULL;
+		}
+		
+		instance->sink = NULL;
+		indev_initialize("kbrd", &instance->raw, &kbrd_raw_ops);
+		
+		spinlock_initialize(&instance->keylock, "instance_keylock");
+		instance->keyflags = 0;
+		instance->lockflags = 0;
+	}
 	
-	if (thread) {
-		stdin = &kbrdout;
-		thread_ready(thread);
-	}
+	return instance;
+}
+
+indev_t *kbrd_wire(kbrd_instance_t *instance, indev_t *sink)
+{
+	ASSERT(instance);
+	ASSERT(sink);
+	
+	instance->sink = sink;
+	thread_ready(instance->thread);
+	
+	return &instance->raw;
 }
 
Index: kernel/genarch/src/srln/srln.c
===================================================================
--- kernel/genarch/src/srln/srln.c	(revision f4b153529231867ef6c64403a465d1f66e1016ca)
+++ kernel/genarch/src/srln/srln.c	(revision a1a83e5e5ddb366d3021bdee2baa08d1a60230fc)
@@ -42,7 +42,5 @@
 #include <string.h>
 
-static indev_t srlnout;
-
-indev_operations_t srlnout_ops = {
+static indev_operations_t srln_raw_ops = {
 	.poll = NULL
 };
@@ -50,10 +48,10 @@
 static void ksrln(void *arg)
 {
-	indev_t *in = (indev_t *) arg;
+	srln_instance_t *instance = (srln_instance_t *) arg;
 	bool cr = false;
 	uint32_t escape = 0;
 	
 	while (true) {
-		wchar_t ch = _getc(in);
+		wchar_t ch = indev_pop_character(&instance->raw);
 		
 		/* ANSI escape sequence processing */
@@ -123,18 +121,37 @@
 			ch = '\b';
 		
-		indev_push_character(stdin, ch);
+		indev_push_character(instance->sink, ch);
 	}
 }
 
-void srln_init(indev_t *devin)
+srln_instance_t *srln_init(void)
 {
-	indev_initialize("srln", &srlnout, &srlnout_ops);
-	thread_t *thread
-	    = thread_create(ksrln, devin, TASK, 0, "ksrln", false);
+	srln_instance_t *instance
+	    = malloc(sizeof(srln_instance_t), FRAME_ATOMIC);
+	if (instance) {
+		instance->thread
+			= thread_create(ksrln, (void *) instance, TASK, 0, "ksrln", false);
+		
+		if (!instance->thread) {
+			free(instance);
+			return NULL;
+		}
+		
+		instance->sink = NULL;
+		indev_initialize("srln", &instance->raw, &srln_raw_ops);
+	}
 	
-	if (thread) {
-		stdin = &srlnout;
-		thread_ready(thread);
-	}
+	return instance;
+}
+
+indev_t *srln_wire(srln_instance_t *instance, indev_t *sink)
+{
+	ASSERT(instance);
+	ASSERT(sink);
+	
+	instance->sink = sink;
+	thread_ready(instance->thread);
+	
+	return &instance->raw;
 }