Changes in / [ac307b2:f571ca49] in mainline

Files:

• .gitignore (modified) (2 diffs)
• uspace/app/sportdmp/sportdmp.c (modified) (5 diffs)
• uspace/app/tester/Makefile (modified) (1 diff)
• uspace/app/tester/hw/misc/virtchar1.c (added)
• uspace/app/tester/hw/misc/virtchar1.def (added)
• uspace/app/tester/hw/serial/serial1.c (modified) (13 diffs)
• uspace/app/tester/tester.c (modified) (1 diff)
• uspace/app/tester/tester.h (modified) (1 diff)
• uspace/drv/char/i8042/buffer.h (added)
• uspace/drv/char/i8042/i8042.c (modified) (9 diffs)
• uspace/drv/char/i8042/i8042.h (modified) (3 diffs)
• uspace/drv/char/msim-con/msim-con.c (modified) (5 diffs)
• uspace/drv/char/msim-con/msim-con.h (modified) (2 diffs)
• uspace/drv/char/ns8250/ns8250.c (modified) (15 diffs)
• uspace/drv/char/ski-con/ski-con.c (modified) (8 diffs)
• uspace/drv/char/ski-con/ski-con.h (modified) (2 diffs)
• uspace/drv/char/sun4v-con/sun4v-con.c (modified) (7 diffs)
• uspace/drv/char/sun4v-con/sun4v-con.h (modified) (2 diffs)
• uspace/drv/root/virt/devices.def (modified) (1 diff)
• uspace/drv/test/test1/Makefile (modified) (1 diff)
• uspace/drv/test/test1/char.c (added)
• uspace/drv/test/test1/test1.c (modified) (1 diff)
• uspace/drv/test/test1/test1.h (modified) (1 diff)
• uspace/lib/c/Makefile (modified) (2 diffs)
• uspace/lib/c/generic/adt/circ_buf.c (deleted)
• uspace/lib/c/generic/io/chardev_srv.c (modified) (1 diff)
• uspace/lib/c/include/adt/circ_buf.h (deleted)
• uspace/lib/c/include/io/chardev_srv.h (modified) (1 diff)
• uspace/lib/c/include/ipc/char.h (added)
• uspace/lib/c/include/ipc/chardev.h (modified) (1 diff)
• uspace/lib/c/include/ipc/serial_ctl.h (modified) (2 diffs)
• uspace/lib/c/test/adt/circ_buf.c (deleted)
• uspace/lib/c/test/main.c (modified) (1 diff)
• uspace/lib/drv/Makefile (modified) (1 diff)
• uspace/lib/drv/generic/dev_iface.c (modified) (2 diffs)
• uspace/lib/drv/generic/private/remote_char_dev.h (added)
• uspace/lib/drv/generic/remote_char_dev.c (added)
• uspace/srv/hid/input/input.c (modified) (5 diffs)
• uspace/srv/hid/input/port/chardev.c (modified) (6 diffs)
• uspace/srv/hid/input/serial.h (modified) (2 diffs)
• uspace/srv/hid/isdv4_tablet/isdv4.c (modified) (8 diffs)
• uspace/srv/hid/isdv4_tablet/isdv4.h (modified) (3 diffs)
• uspace/srv/hid/output/port/chardev.c (modified) (4 diffs)
• uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c (modified) (9 diffs)
• uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.h (modified) (3 diffs)
• uspace/srv/net/slip/slip.c (modified) (13 diffs)

.gitignore

@@ -248 +248 @@
 uspace/dist/logo.tga
 uspace/dist/srv/cdfs
-uspace/dist/srv/chardev-test
 uspace/dist/srv/clipboard
 uspace/dist/srv/compositor
@@ -421 +420 @@
 uspace/srv/ns/ns
 uspace/srv/taskmon/taskmon
-uspace/srv/test/chardev-test/chardev-test
 uspace/srv/vfs/vfs
 uspace/srv/volsrv/volsrv

uspace/app/sportdmp/sportdmp.c

@@ -27 +27 @@
  */
 
+#include <char_dev_iface.h>
 #include <errno.h>
-#include <io/chardev.h>
 #include <io/serial.h>
 #include <loc.h>
 #include <stdio.h>
-#include <stdlib.h>
 
 #define BUF_SIZE 1
@@ -45 +44 @@
         sysarg_t baud = 9600;
         service_id_t svc_id;
-        chardev_t *chardev;
         serial_t *serial;
-        size_t nread;
 
         int arg = 1;
@@ -122 +119 @@
         }
 
-        rc = chardev_open(sess, &chardev);
-        if (rc != EOK) {
-                fprintf(stderr, "Failed opening character device\n");
-                return 2;
-        }
-
         rc = serial_open(sess, &serial);
         if (rc != EOK) {
@@ -147 +138 @@
 
         while (true) {
-                rc = chardev_read(chardev, buf, BUF_SIZE, &nread);
-                for (size_t i = 0; i < nread; i++) {
+                ssize_t read = char_dev_read(sess, buf, BUF_SIZE);
+                if (read < 0) {
+                        fprintf(stderr, "Failed reading from serial device\n");
+                        break;
+                }
+                ssize_t i;
+                for (i = 0; i < read; i++) {
                         printf("%02hhx ", buf[i]);
-                }
-                if (rc != EOK) {
-                        fprintf(stderr, "\nFailed reading from serial device\n");
-                        break;
                 }
                 fflush(stdout);
@@ -160 +152 @@
         free(buf);
         serial_close(serial);
-        chardev_close(chardev);
         async_hangup(sess);
         return 0;

uspace/app/tester/Makefile

@@ -68 +68 @@
         mm/mapping1.c \
         mm/pager1.c \
+        hw/misc/virtchar1.c \
         hw/serial/serial1.c \
         chardev/chardev1.c

uspace/app/tester/hw/serial/serial1.c

@@ -35 +35 @@
  */
 
-#include <async.h>
+#include <inttypes.h>
 #include <errno.h>
-#include <io/chardev.h>
-#include <io/serial.h>
-#include <ipc/services.h>
-#include <loc.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <stddef.h>
+#include <async.h>
+#include <thread.h>
+#include <ipc/services.h>
+#include <loc.h>
+#include <char_dev_iface.h>
 #include <str.h>
-#include <thread.h>
+#include <io/serial.h>
 #include "../../tester.h"
 
@@ -56 +57 @@
         size_t cnt;
         serial_t *serial;
-        chardev_t *chardev;
-        int rc;
-        size_t nread;
-        size_t nwritten;
         
         if (test_argc < 1)
@@ -86 +83 @@
                 return "Failed connecting to serial device";
         
-        res = chardev_open(sess, &chardev);
-        if (res != EOK) {
-                async_hangup(sess);
+        res = serial_open(sess, &serial);
+        if (res != EOK)
                 return "Failed opening serial port";
-        }
-        
-        res = serial_open(sess, &serial);
-        if (res != EOK) {
-                chardev_close(chardev);
-                async_hangup(sess);
-                return "Failed opening serial port";
-        }
         
         char *buf = (char *) malloc(cnt + 1);
         if (buf == NULL) {
-                chardev_close(chardev);
                 serial_close(serial);
                 async_hangup(sess);
@@ -116 +103 @@
         if (res != EOK) {
                 free(buf);
-                chardev_close(chardev);
                 serial_close(serial);
                 async_hangup(sess);
@@ -125 +111 @@
         if (EOK != res) {
                 free(buf);
-                chardev_close(chardev);
                 serial_close(serial);
                 async_hangup(sess);
@@ -136 +121 @@
         size_t total = 0;
         while (total < cnt) {
-                
-                rc = chardev_read(chardev, buf, cnt - total, &nread);
-                if (rc != EOK) {
+                ssize_t read = char_dev_read(sess, buf, cnt - total);
+                
+                if (read < 0) {
                         (void) serial_set_comm_props(serial, old_baud,
                             old_par, old_word_size, old_stop);
                         
                         free(buf);
-                        chardev_close(chardev);
                         serial_close(serial);
                         async_hangup(sess);
@@ -149 +133 @@
                 }
                 
-                if (nread > cnt - total) {
+                if ((size_t) read > cnt - total) {
                         (void) serial_set_comm_props(serial, old_baud,
                             old_par, old_word_size, old_stop);
                         
                         free(buf);
-                        chardev_close(chardev);
                         serial_close(serial);
                         async_hangup(sess);
@@ -160 +143 @@
                 }
                 
-                TPRINTF("Read %zd bytes\n", nread);
-                
-                if (nread == 0)
+                TPRINTF("Read %zd bytes\n", read);
+                
+                if (read == 0)
                         thread_usleep(DEFAULT_SLEEP);
                 else {
-                        buf[nread] = 0;
+                        buf[read] = 0;
                         
                         /*
@@ -171 +154 @@
                          * direction of data transfer.
                          */
-                        rc = chardev_write(chardev, buf, nread, &nwritten);
-                        if (rc != EOK) {
+                        ssize_t written = char_dev_write(sess, buf, read);
+                        
+                        if (written < 0) {
                                 (void) serial_set_comm_props(serial, old_baud,
                                     old_par, old_word_size, old_stop);
                                 
                                 free(buf);
-                                chardev_close(chardev);
                                 serial_close(serial);
                                 async_hangup(sess);
@@ -183 +166 @@
                         }
                         
-                        if (nwritten != nread) {
+                        if (written != read) {
                                 (void) serial_set_comm_props(serial, old_baud,
                                     old_par, old_word_size, old_stop);
                                 
                                 free(buf);
-                                chardev_close(chardev);
                                 serial_close(serial);
                                 async_hangup(sess);
@@ -194 +176 @@
                         }
                         
-                        TPRINTF("Written %zd bytes\n", nwritten);
-                }
-                
-                total += nread;
+                        TPRINTF("Written %zd bytes\n", written);
+                }
+                
+                total += read;
         }
         
@@ -203 +185 @@
         
         size_t eot_size = str_size(EOT);
-        rc = chardev_write(chardev, (void *) EOT, eot_size, &nwritten);
+        ssize_t written = char_dev_write(sess, (void *) EOT, eot_size);
         
         (void) serial_set_comm_props(serial, old_baud, old_par, old_word_size,
@@ -209 +191 @@
         
         free(buf);
-        chardev_close(chardev);
         serial_close(serial);
         async_hangup(sess);
         
-        if (rc != EOK)
+        if (written < 0)
                 return "Failed to write EOT banner to serial device";
         
-        if (nwritten != eot_size)
+        if ((size_t) written != eot_size)
                 return "Written less data than the size of the EOT banner "
                     "to serial device";

uspace/app/tester/tester.c

@@ -76 +76 @@
 #include "mm/pager1.def"
 #include "hw/serial/serial1.def"
+#include "hw/misc/virtchar1.def"
 #include "chardev/chardev1.def"
         {NULL, NULL, NULL, false}

uspace/app/tester/tester.h

@@ -108 +108 @@
 extern const char *test_pager1(void);
 extern const char *test_serial1(void);
+extern const char *test_virtchar1(void);
 extern const char *test_devman1(void);
 extern const char *test_devman2(void);

uspace/drv/char/i8042/i8042.c

@@ -2 +2 @@
  * Copyright (c) 2001-2004 Jakub Jermar
  * Copyright (c) 2006 Josef Cejka
- * Copyright (c) 2017 Jiri Svoboda
+ * Copyright (c) 2014 Jiri Svoboda
  * Copyright (c) 2011 Jan Vesely
  * All rights reserved.
@@ -39 +39 @@
  */
 
-#include <adt/circ_buf.h>
 #include <ddf/log.h>
 #include <ddf/interrupt.h>
@@ -131 +130 @@
 {
         i8042_t *controller = ddf_dev_data_get(dev);
-        int rc;
         
         const uint8_t status = IPC_GET_ARG1(*call);
         const uint8_t data = IPC_GET_ARG2(*call);
         
-        i8042_port_t *port = (status & i8042_AUX_DATA) ?
-            controller->aux : controller->kbd;
-        
-        fibril_mutex_lock(&port->buf_lock);
-        
-        rc = circ_buf_push(&port->cbuf, &data);
-        if (rc != EOK)
-                ddf_msg(LVL_ERROR, "Buffer overrun");
-
-        fibril_mutex_unlock(&port->buf_lock);
-        fibril_condvar_broadcast(&port->buf_cv);
+        buffer_t *buffer = (status & i8042_AUX_DATA) ?
+            &controller->aux_buffer : &controller->kbd_buffer;
+        
+        buffer_write(buffer, data);
 }
 
@@ -168 +159 @@
         const size_t cmd_count = sizeof(i8042_cmds) / sizeof(irq_cmd_t);
         irq_cmd_t cmds[cmd_count];
-        ddf_fun_t *kbd_fun;
-        ddf_fun_t *aux_fun;
         i8042_regs_t *ar;
-        
+
         int rc;
         bool kbd_bound = false;
         bool aux_bound = false;
+
+        dev->kbd_fun = NULL;
+        dev->aux_fun = NULL;
         
         if (regs->size < sizeof(i8042_regs_t)) {
@@ -186 +178 @@
         }
         
-        kbd_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2a");
-        if (kbd_fun == NULL) {
+        dev->kbd_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2a");
+        if (dev->kbd_fun == NULL) {
                 rc = ENOMEM;
                 goto error;
         };
         
-        dev->kbd = ddf_fun_data_alloc(kbd_fun, sizeof(i8042_port_t));
+        dev->kbd = ddf_fun_data_alloc(dev->kbd_fun, sizeof(i8042_port_t));
         if (dev->kbd == NULL) {
                 rc = ENOMEM;
@@ -198 +190 @@
         }
         
-        dev->kbd->fun = kbd_fun;
         dev->kbd->ctl = dev;
         chardev_srvs_init(&dev->kbd->cds);
         dev->kbd->cds.ops = &i8042_chardev_ops;
         dev->kbd->cds.sarg = dev->kbd;
-        fibril_mutex_initialize(&dev->kbd->buf_lock);
-        fibril_condvar_initialize(&dev->kbd->buf_cv);
-        
-        rc = ddf_fun_add_match_id(dev->kbd->fun, "char/xtkbd", 90);
+        
+        rc = ddf_fun_add_match_id(dev->kbd_fun, "char/xtkbd", 90);
         if (rc != EOK)
                 goto error;
         
-        aux_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2b");
-        if (aux_fun == NULL) {
+        dev->aux_fun = ddf_fun_create(ddf_dev, fun_inner, "ps2b");
+        if (dev->aux_fun == NULL) {
                 rc = ENOMEM;
                 goto error;
         }
         
-        dev->aux = ddf_fun_data_alloc(aux_fun, sizeof(i8042_port_t));
+        dev->aux = ddf_fun_data_alloc(dev->aux_fun, sizeof(i8042_port_t));
         if (dev->aux == NULL) {
                 rc = ENOMEM;
@@ -222 +211 @@
         }
         
-        dev->aux->fun = aux_fun;
         dev->aux->ctl = dev;
         chardev_srvs_init(&dev->aux->cds);
         dev->aux->cds.ops = &i8042_chardev_ops;
         dev->aux->cds.sarg = dev->aux;
-        fibril_mutex_initialize(&dev->aux->buf_lock);
-        fibril_condvar_initialize(&dev->aux->buf_cv);
-        
-        rc = ddf_fun_add_match_id(dev->aux->fun, "char/ps2mouse", 90);
+        
+        rc = ddf_fun_add_match_id(dev->aux_fun, "char/ps2mouse", 90);
         if (rc != EOK)
                 goto error;
         
-        ddf_fun_set_conn_handler(dev->kbd->fun, i8042_char_conn);
-        ddf_fun_set_conn_handler(dev->aux->fun, i8042_char_conn);
-        
-        circ_buf_init(&dev->kbd->cbuf, dev->kbd->buf_data, BUFFER_SIZE, 1);
-        circ_buf_init(&dev->aux->cbuf, dev->aux->buf_data, BUFFER_SIZE, 1);
+        ddf_fun_set_conn_handler(dev->kbd_fun, i8042_char_conn);
+        ddf_fun_set_conn_handler(dev->aux_fun, i8042_char_conn);
+        
+        buffer_init(&dev->kbd_buffer, dev->kbd_data, BUFFER_SIZE);
+        buffer_init(&dev->aux_buffer, dev->aux_data, BUFFER_SIZE);
         fibril_mutex_initialize(&dev->write_guard);
         
-        rc = ddf_fun_bind(dev->kbd->fun);
+        rc = ddf_fun_bind(dev->kbd_fun);
         if (rc != EOK) {
                 ddf_msg(LVL_ERROR, "Failed to bind keyboard function: %s.",
-                    ddf_fun_get_name(dev->kbd->fun));
+                    ddf_fun_get_name(dev->kbd_fun));
                 goto error;
         }
         kbd_bound = true;
         
-        rc = ddf_fun_bind(dev->aux->fun);
+        rc = ddf_fun_bind(dev->aux_fun);
         if (rc != EOK) {
                 ddf_msg(LVL_ERROR, "Failed to bind aux function: %s.",
-                    ddf_fun_get_name(dev->aux->fun));
+                    ddf_fun_get_name(dev->aux_fun));
                 goto error;
         }
@@ -331 +317 @@
 error:
         if (kbd_bound)
-                ddf_fun_unbind(dev->kbd->fun);
+                ddf_fun_unbind(dev->kbd_fun);
         if (aux_bound)
-                ddf_fun_unbind(dev->aux->fun);
-        if (dev->kbd->fun != NULL)
-                ddf_fun_destroy(dev->kbd->fun);
-        if (dev->aux->fun != NULL)
-                ddf_fun_destroy(dev->aux->fun);
+                ddf_fun_unbind(dev->aux_fun);
+        if (dev->kbd_fun != NULL)
+                ddf_fun_destroy(dev->kbd_fun);
+        if (dev->aux_fun != NULL)
+                ddf_fun_destroy(dev->aux_fun);
 
         return rc;
@@ -391 +377 @@
 {
         i8042_port_t *port = (i8042_port_t *)srv->srvs->sarg;
-        size_t p;
+        i8042_t *i8042 = port->ctl;
         uint8_t *destp = (uint8_t *)dest;
         int rc;
-        
-        fibril_mutex_lock(&port->buf_lock);
-        
-        while (circ_buf_nused(&port->cbuf) == 0)
-                fibril_condvar_wait(&port->buf_cv, &port->buf_lock);
-
-        p = 0;
-        while (p < size) {
-                rc = circ_buf_pop(&port->cbuf, &destp[p]);
+        size_t i;
+        
+        buffer_t *buffer = (port == i8042->aux) ?
+            &i8042->aux_buffer : &i8042->kbd_buffer;
+        
+        for (i = 0; i < size; ++i) {
+                rc = buffer_read(buffer, destp, i == 0);
                 if (rc != EOK)
                         break;
-                ++p;
-        }
-
-        fibril_mutex_unlock(&port->buf_lock);
-
-        *nread = p;
+                ++destp;
+        }
+        
+        *nread = i;
         return EOK;
 }

uspace/drv/char/i8042/i8042.h

@@ -2 +2 @@
  * Copyright (c) 2006 Josef Cejka
  * Copyright (c) 2011 Jan Vesely
- * Copyright (c) 2017 Jiri Svoboda
  * All rights reserved.
  *
@@ -41 +40 @@
 #define i8042_H_
 
-#include <adt/circ_buf.h>
 #include <io/chardev_srv.h>
 #include <ddi.h>
 #include <fibril_synch.h>
 #include <ddf/driver.h>
+#include "buffer.h"
 
 #define NAME  "i8042"
@@ -60 +59 @@
 /** i8042 Port. */
 typedef struct {
-        /** Controller */
-        struct i8042 *ctl;
-        /** Device function */
-        ddf_fun_t *fun;
-        /** Character device server data */
-        chardev_srvs_t cds;
-        /** Circular buffer */
-        circ_buf_t cbuf;
-        /** Buffer data space */
-        uint8_t buf_data[BUFFER_SIZE];
-        /** Protect buffer */
-        fibril_mutex_t buf_lock;
-        /** Signal new data in buffer */
-        fibril_condvar_t buf_cv;
+        struct i8042 *ctl;              /**< Controller */
+        chardev_srvs_t cds;             /**< Character device server data */
 } i8042_port_t;
 
 /** i8042 Controller. */
 typedef struct i8042 {
-        /**< I/O registers. */
-        i8042_regs_t *regs;
-        /** Keyboard port */
+        i8042_regs_t *regs;             /**< I/O registers. */
+        ddf_fun_t *kbd_fun;             /**< Pirmary port device function. */
+        ddf_fun_t *aux_fun;             /**< Auxiliary port device function. */
+        buffer_t kbd_buffer;            /**< Primary port buffer. */
+        buffer_t aux_buffer;            /**< Aux. port buffer. */
+        uint8_t aux_data[BUFFER_SIZE];  /**< Primary port buffer space. */
+        uint8_t kbd_data[BUFFER_SIZE];  /**< Aux. port buffer space. */
         i8042_port_t *kbd;
-        /** AUX port */
         i8042_port_t *aux;
-        /** Prevents simultanous port writes.*/
-        fibril_mutex_t write_guard;
+        fibril_mutex_t write_guard;     /**< Prevents simultanous port writes.*/
 } i8042_t;
+
 
 extern int i8042_init(i8042_t *, addr_range_t *, int, int, ddf_dev_t *);

uspace/drv/char/msim-con/msim-con.c

@@ -37 +37 @@
 #include <ddi.h>
 #include <errno.h>
-#include <io/chardev_srv.h>
+#include <ipc/char.h>
 
 #include "msim-con.h"
 
 static void msim_con_connection(ipc_callid_t, ipc_call_t *, void *);
-
-static int msim_con_read(chardev_srv_t *, void *, size_t, size_t *);
-static int msim_con_write(chardev_srv_t *, const void *, size_t, size_t *);
-
-static chardev_ops_t msim_con_chardev_ops = {
-        .read = msim_con_read,
-        .write = msim_con_write
-};
 
 static irq_cmd_t msim_cmds_proto[] = {
@@ -66 +58 @@
         msim_con_t *con = (msim_con_t *) arg;
         uint8_t c;
-        int rc;
-
-        fibril_mutex_lock(&con->buf_lock);
 
         c = IPC_GET_ARG2(*call);
-        rc = circ_buf_push(&con->cbuf, &c);
-        if (rc != EOK)
-                ddf_msg(LVL_ERROR, "Buffer overrun");
 
-        fibril_mutex_unlock(&con->buf_lock);
-        fibril_condvar_broadcast(&con->buf_cv);
+        if (con->client_sess != NULL) {
+                async_exch_t *exch = async_exchange_begin(con->client_sess);
+                async_msg_1(exch, CHAR_NOTIF_BYTE, c);
+                async_exchange_end(exch);
+        }
 }
 
@@ -86 +75 @@
         irq_cmd_t *msim_cmds = NULL;
         int rc;
-
-        circ_buf_init(&con->cbuf, con->buf, msim_con_buf_size, 1);
-        fibril_mutex_initialize(&con->buf_lock);
-        fibril_condvar_initialize(&con->buf_cv);
 
         msim_cmds = malloc(sizeof(msim_cmds_proto));
@@ -121 +106 @@
         async_irq_subscribe(res->irq, msim_irq_handler, con, &con->irq_code);
         subscribed = true;
-
-        chardev_srvs_init(&con->cds);
-        con->cds.ops = &msim_con_chardev_ops;
-        con->cds.sarg = con;
 
         rc = ddf_fun_bind(fun);
@@ -159 +140 @@
 }
 
-/** Read from msim console device */
-static int msim_con_read(chardev_srv_t *srv, void *buf, size_t size,
-    size_t *nread)
-{
-        msim_con_t *con = (msim_con_t *) srv->srvs->sarg;
-        size_t p;
-        uint8_t *bp = (uint8_t *) buf;
-        int rc;
-
-        fibril_mutex_lock(&con->buf_lock);
-
-        while (circ_buf_nused(&con->cbuf) == 0)
-                fibril_condvar_wait(&con->buf_cv, &con->buf_lock);
-
-        p = 0;
-        while (p < size) {
-                rc = circ_buf_pop(&con->cbuf, &bp[p]);
-                if (rc != EOK)
-                        break;
-                ++p;
-        }
-
-        fibril_mutex_unlock(&con->buf_lock);
-
-        *nread = p;
-        return EOK;
-}
-
-/** Write to msim console device */
-static int msim_con_write(chardev_srv_t *srv, const void *data, size_t size,
-    size_t *nwr)
-{
-        msim_con_t *con = (msim_con_t *) srv->srvs->sarg;
-        size_t i;
-        uint8_t *dp = (uint8_t *) data;
-
-        for (i = 0; i < size; i++)
-                msim_con_putchar(con, dp[i]); 
-
-        *nwr = size;
-        return EOK;
-}
-
 /** Character device connection handler. */
 static void msim_con_connection(ipc_callid_t iid, ipc_call_t *icall,
     void *arg)
 {
-        msim_con_t *con = (msim_con_t *) ddf_dev_data_get(
-            ddf_fun_get_dev((ddf_fun_t *) arg));
+        msim_con_t *con;
 
-        chardev_conn(iid, icall, &con->cds);
+        /* Answer the IPC_M_CONNECT_ME_TO call. */
+        async_answer_0(iid, EOK);
+
+        con = (msim_con_t *)ddf_dev_data_get(ddf_fun_get_dev((ddf_fun_t *)arg));
+
+        while (true) {
+                ipc_call_t call;
+                ipc_callid_t callid = async_get_call(&call);
+                sysarg_t method = IPC_GET_IMETHOD(call);
+
+                if (!method) {
+                        /* The other side has hung up. */
+                        async_answer_0(callid, EOK);
+                        return;
+                }
+
+                async_sess_t *sess =
+                    async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
+                if (sess != NULL) {
+                        if (con->client_sess == NULL) {
+                                con->client_sess = sess;
+                                async_answer_0(callid, EOK);
+                        } else
+                                async_answer_0(callid, ELIMIT);
+                } else {
+                        switch (method) {
+                        case CHAR_WRITE_BYTE:
+                                ddf_msg(LVL_DEBUG, "Write %" PRIun " to device\n",
+                                    IPC_GET_ARG1(call));
+                                msim_con_putchar(con, (uint8_t) IPC_GET_ARG1(call));
+                                async_answer_0(callid, EOK);
+                                break;
+                        default:
+                                async_answer_0(callid, EINVAL);
+                        }
+                }
+        }
 }
 

uspace/drv/char/msim-con/msim-con.h

@@ -36 +36 @@
 #define MSIM_CON_H
 
-#include <adt/circ_buf.h>
 #include <async.h>
 #include <ddf/driver.h>
-#include <fibril_synch.h>
-#include <io/chardev_srv.h>
 #include <loc.h>
 #include <stdint.h>
-
-enum {
-        msim_con_buf_size = 64
-};
 
 /** MSIM console resources */
@@ -58 +51 @@
         async_sess_t *client_sess;
         ddf_dev_t *dev;
-        chardev_srvs_t cds;
         msim_con_res_t res;
         irq_pio_range_t irq_range[1];
         irq_code_t irq_code;
-        circ_buf_t cbuf;
-        uint8_t buf[msim_con_buf_size];
-        fibril_mutex_t buf_lock;
-        fibril_condvar_t buf_cv;
 } msim_con_t;
 

uspace/drv/char/ns8250/ns8250.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2010 Lenka Trochtova
- * Copyright (c) 2017 Jiri Svoboda
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -53 +53 @@
 #include <ddf/interrupt.h>
 #include <ddf/log.h>
-#include <io/chardev_srv.h>
+#include <ops/char_dev.h>
 
 #include <device/hw_res.h>
@@ -153 +153 @@
         /** DDF function node */
         ddf_fun_t *fun;
-        /** Character device service */
-        chardev_srvs_t cds;
         /** Parent session */
         async_sess_t *parent_sess;
@@ -191 +189 @@
 }
 
-/** Obtain soft-state structure from chardev srv */
-static ns8250_t *srv_ns8250(chardev_srv_t *srv)
-{
-        return (ns8250_t *)srv->srvs->sarg;
-}
-
-
 /** Find out if there is some incoming data available on the serial port.
  *
@@ -243 +234 @@
 /** Read data from the serial port device.
  *
- * @param srv           Server-side connection data
+ * @param fun           The serial port function
  * @param buf           The output buffer for read data.
  * @param count         The number of bytes to be read.
- * @param nread         Place to store number of bytes actually read
- *
- * @return              EOK on success or non-zero error code
- */
-static int ns8250_read(chardev_srv_t *srv, void *buf, size_t count, size_t *nread)
-{
-        ns8250_t *ns = srv_ns8250(srv);
-        char *bp = (char *) buf;
-        size_t pos = 0;
-        
-        if (count == 0) {
-                *nread = 0;
-                return EOK;
-        }
+ *
+ * @return              The number of bytes actually read on success, negative
+ *                      error number otherwise.
+ */
+static int ns8250_read(ddf_fun_t *fun, char *buf, size_t count)
+{
+        ns8250_t *ns = fun_ns8250(fun);
+        int ret = 0;
+        
+        if (count == 0) return 0;
         
         fibril_mutex_lock(&ns->mutex);
         while (buf_is_empty(&ns->input_buffer))
                 fibril_condvar_wait(&ns->input_buffer_available, &ns->mutex);
-        while (!buf_is_empty(&ns->input_buffer) && pos < count) {
-                bp[pos] = (char)buf_pop_front(&ns->input_buffer);
-                pos++;
+        while (!buf_is_empty(&ns->input_buffer) && (size_t)ret < count) {
+                buf[ret] = (char)buf_pop_front(&ns->input_buffer);
+                ret++;
         }
         fibril_mutex_unlock(&ns->mutex);
         
-        *nread = pos;
-        return EOK;
+        return ret;
 }
 
@@ -288 +274 @@
 /** Write data to the serial port.
  *
- * @param srv           Server-side connection data
+ * @param fun           The serial port function
  * @param buf           The data to be written
  * @param count         The number of bytes to be written
- * @param nwritten      Place to store number of bytes successfully written
- * @return              EOK on success or non-zero error code
- */
-static int ns8250_write(chardev_srv_t *srv, const void *buf, size_t count,
-    size_t *nwritten)
-{
-        ns8250_t *ns = srv_ns8250(srv);
+ * @return              Zero on success
+ */
+static int ns8250_write(ddf_fun_t *fun, char *buf, size_t count)
+{
+        ns8250_t *ns = fun_ns8250(fun);
         size_t idx;
-        uint8_t *bp = (uint8_t *) buf;
         
         for (idx = 0; idx < count; idx++)
-                ns8250_putchar(ns, bp[idx]);
-        
-        *nwritten = count;
-        return EOK;
-}
-
-static int ns8250_open(chardev_srvs_t *, chardev_srv_t *);
-static int ns8250_close(chardev_srv_t *);
-static void ns8250_default_handler(chardev_srv_t *, ipc_callid_t, ipc_call_t *);
+                ns8250_putchar(ns, (uint8_t) buf[idx]);
+        
+        return count;
+}
+
+static ddf_dev_ops_t ns8250_dev_ops;
 
 /** The character interface's callbacks. */
-static chardev_ops_t ns8250_chardev_ops = {
-        .open = ns8250_open,
-        .close = ns8250_close,
-        .read = ns8250_read,
-        .write = ns8250_write,
-        .def_handler = ns8250_default_handler
+static char_dev_ops_t ns8250_char_dev_ops = {
+        .read = &ns8250_read,
+        .write = &ns8250_write
 };
-
-static void ns8250_char_conn(ipc_callid_t, ipc_call_t *, void *);
 
 static int ns8250_dev_add(ddf_dev_t *dev);
@@ -897 +872 @@
         }
         
-        ddf_fun_set_conn_handler(fun, ns8250_char_conn);
-        
-        chardev_srvs_init(&ns->cds);
-        ns->cds.ops = &ns8250_chardev_ops;
-        ns->cds.sarg = ns;
-        
+        /* Set device operations. */
+        ddf_fun_set_ops(fun, &ns8250_dev_ops);
         rc = ddf_fun_bind(fun);
         if (rc != EOK) {
@@ -959 +930 @@
  * device.
  *
- * @param srvs          Service structure
- * @param srv           Server-side connection structure
- */
-static int ns8250_open(chardev_srvs_t *srvs, chardev_srv_t *srv)
-{
-        ns8250_t *ns = srv_ns8250(srv);
+ * @param dev           The device.
+ */
+static int ns8250_open(ddf_fun_t *fun)
+{
+        ns8250_t *ns = fun_ns8250(fun);
         int res;
         
@@ -984 +954 @@
  * the device.
  *
- * @param srv           Server-side connection structure
- */
-static int ns8250_close(chardev_srv_t *srv)
-{
-        ns8250_t *data = srv_ns8250(srv);
+ * @param dev           The device.
+ */
+static void ns8250_close(ddf_fun_t *fun)
+{
+        ns8250_t *data = fun_ns8250(fun);
         
         fibril_mutex_lock(&data->mutex);
@@ -998 +968 @@
         
         fibril_mutex_unlock(&data->mutex);
-        
-        return EOK;
 }
 
@@ -1066 +1034 @@
  * Configure the parameters of the serial communication.
  */
-static void ns8250_default_handler(chardev_srv_t *srv, ipc_callid_t callid,
+static void ns8250_default_handler(ddf_fun_t *fun, ipc_callid_t callid,
     ipc_call_t *call)
 {
-        ns8250_t *ns8250 = srv_ns8250(srv);
         sysarg_t method = IPC_GET_IMETHOD(*call);
         int ret;
@@ -1076 +1043 @@
         switch (method) {
         case SERIAL_GET_COM_PROPS:
-                ns8250_get_props(ns8250->dev, &baud_rate, &parity, &word_length,
+                ns8250_get_props(ddf_fun_get_dev(fun), &baud_rate, &parity, &word_length,
                     &stop_bits);
                 async_answer_4(callid, EOK, baud_rate, parity, word_length,
@@ -1087 +1054 @@
                 word_length = IPC_GET_ARG3(*call);
                 stop_bits = IPC_GET_ARG4(*call);
-                ret = ns8250_set_props(ns8250->dev, baud_rate, parity, word_length,
+                ret = ns8250_set_props(ddf_fun_get_dev(fun), baud_rate, parity, word_length,
                     stop_bits);
                 async_answer_0(callid, ret);
@@ -1097 +1064 @@
 }
 
-void ns8250_char_conn(ipc_callid_t iid, ipc_call_t *icall, void *arg)
-{
-        ns8250_t *ns8250 = fun_ns8250((ddf_fun_t *)arg);
-
-        chardev_conn(iid, icall, &ns8250->cds);
-}
-
 /** Initialize the serial port driver.
  *
@@ -1112 +1072 @@
 {
         ddf_log_init(NAME);
+        
+        ns8250_dev_ops.open = &ns8250_open;
+        ns8250_dev_ops.close = &ns8250_close;
+        
+        ns8250_dev_ops.interfaces[CHAR_DEV_IFACE] = &ns8250_char_dev_ops;
+        ns8250_dev_ops.default_handler = &ns8250_default_handler;
 }
 

uspace/drv/char/ski-con/ski-con.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2005 Jakub Jermar
- * Copyright (c) 2017 Jiri Svoboda
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -34 +34 @@
 #include <ddf/log.h>
 #include <errno.h>
-#include <fibril.h>
-#include <io/chardev.h>
+#include <ipc/char.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <thread.h>
 #include <stdbool.h>
 
@@ -46 +46 @@
 #define POLL_INTERVAL           10000
 
-static int ski_con_fibril(void *arg);
+static void ski_con_thread_impl(void *arg);
 static int32_t ski_con_getchar(void);
 static void ski_con_connection(ipc_callid_t, ipc_call_t *, void *);
 
-static int ski_con_read(chardev_srv_t *, void *, size_t, size_t *);
-static int ski_con_write(chardev_srv_t *, const void *, size_t, size_t *);
-
-static chardev_ops_t ski_con_chardev_ops = {
-        .read = ski_con_read,
-        .write = ski_con_write
-};
-
 /** Add ski console device. */
 int ski_con_add(ski_con_t *con)
 {
-        fid_t fid;
+        thread_id_t tid;
         ddf_fun_t *fun = NULL;
         bool bound = false;
         int rc;
-
-        circ_buf_init(&con->cbuf, con->buf, ski_con_buf_size, 1);
-        fibril_mutex_initialize(&con->buf_lock);
-        fibril_condvar_initialize(&con->buf_cv);
 
         fun = ddf_fun_create(con->dev, fun_exposed, "a");
@@ -79 +67 @@
         ddf_fun_set_conn_handler(fun, ski_con_connection);
 
-        chardev_srvs_init(&con->cds);
-        con->cds.ops = &ski_con_chardev_ops;
-        con->cds.sarg = con;
-
         rc = ddf_fun_bind(fun);
         if (rc != EOK) {
@@ -91 +75 @@
         bound = true;
 
-        fid = fibril_create(ski_con_fibril, con);
-        if (fid == 0) {
-                ddf_msg(LVL_ERROR, "Error creating fibril.");
-                rc = ENOMEM;
-                goto error;
-        }
-
-        fibril_add_ready(fid);
+        rc = thread_create(ski_con_thread_impl, con, "kbd_poll", &tid);
+        if (rc != 0) {
+                return rc;
+        }
+
         return EOK;
 error:
@@ -121 +102 @@
 }
 
-/** Poll Ski for keypresses. */
-static int ski_con_fibril(void *arg)
+/** Thread to poll Ski for keypresses. */
+static void ski_con_thread_impl(void *arg)
 {
         int32_t c;
         ski_con_t *con = (ski_con_t *) arg;
-        int rc;
 
         while (1) {
@@ -134 +114 @@
                                 break;
 
-                        fibril_mutex_lock(&con->buf_lock);
-
-                        rc = circ_buf_push(&con->cbuf, &c);
-                        if (rc != EOK)
-                                ddf_msg(LVL_ERROR, "Buffer overrun");
-
-                        fibril_mutex_unlock(&con->buf_lock);
-                        fibril_condvar_broadcast(&con->buf_cv);
+                        if (con->client_sess != NULL) {
+                                async_exch_t *exch = async_exchange_begin(con->client_sess);
+                                async_msg_1(exch, CHAR_NOTIF_BYTE, c);
+                                async_exchange_end(exch);
+                        }
                 }
 
-                fibril_usleep(POLL_INTERVAL);
-        }
-
-        return 0;
+                thread_usleep(POLL_INTERVAL);
+        }
 }
 
@@ -182 +157 @@
 }
 
-/** Read from Ski console device */
-static int ski_con_read(chardev_srv_t *srv, void *buf, size_t size,
-    size_t *nread)
-{
-        ski_con_t *con = (ski_con_t *) srv->srvs->sarg;
-        size_t p;
-        uint8_t *bp = (uint8_t *) buf;
-        int rc;
-
-        fibril_mutex_lock(&con->buf_lock);
-
-        while (circ_buf_nused(&con->cbuf) == 0)
-                fibril_condvar_wait(&con->buf_cv, &con->buf_lock);
-
-        p = 0;
-        while (p < size) {
-                rc = circ_buf_pop(&con->cbuf, &bp[p]);
-                if (rc != EOK)
-                        break;
-                ++p;
-        }
-
-        fibril_mutex_unlock(&con->buf_lock);
-
-        *nread = p;
-        return EOK;
-}
-
-/** Write to Ski console device */
-static int ski_con_write(chardev_srv_t *srv, const void *data, size_t size,
-    size_t *nwr)
-{
-        ski_con_t *con = (ski_con_t *) srv->srvs->sarg;
-        size_t i;
-        uint8_t *dp = (uint8_t *) data;
-
-        for (i = 0; i < size; i++)
-                ski_con_putchar(con, dp[i]); 
-
-        *nwr = size;
-        return EOK;
-}
-
 /** Character device connection handler. */
 static void ski_con_connection(ipc_callid_t iid, ipc_call_t *icall,
     void *arg)
 {
-        ski_con_t *con = (ski_con_t *) ddf_dev_data_get(
-            ddf_fun_get_dev((ddf_fun_t *) arg));
-
-        chardev_conn(iid, icall, &con->cds);
+        ski_con_t *con;
+
+        /* Answer the IPC_M_CONNECT_ME_TO call. */
+        async_answer_0(iid, EOK);
+
+        con = (ski_con_t *)ddf_dev_data_get(ddf_fun_get_dev((ddf_fun_t *)arg));
+
+        while (true) {
+                ipc_call_t call;
+                ipc_callid_t callid = async_get_call(&call);
+                sysarg_t method = IPC_GET_IMETHOD(call);
+
+                if (!method) {
+                        /* The other side has hung up. */
+                        async_answer_0(callid, EOK);
+                        return;
+                }
+
+                async_sess_t *sess =
+                    async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
+                if (sess != NULL) {
+                        if (con->client_sess == NULL) {
+                                con->client_sess = sess;
+                                async_answer_0(callid, EOK);
+                        } else
+                                async_answer_0(callid, ELIMIT);
+                } else {
+                        switch (method) {
+                        case CHAR_WRITE_BYTE:
+                                ddf_msg(LVL_DEBUG, "Write %" PRIun " to device\n",
+                                    IPC_GET_ARG1(call));
+                                ski_con_putchar(con, (uint8_t) IPC_GET_ARG1(call));
+                                async_answer_0(callid, EOK);
+                                break;
+                        default:
+                                async_answer_0(callid, EINVAL);
+                        }
+                }
+        }
 }
 

uspace/drv/char/ski-con/ski-con.h

@@ -36 +36 @@
 #define SKI_CON_H
 
-#include <adt/circ_buf.h>
 #include <async.h>
 #include <ddf/driver.h>
-#include <io/chardev_srv.h>
 #include <loc.h>
 #include <stdint.h>
-
-enum {
-        ski_con_buf_size = 64
-};
 
 /** Ski console */
@@ -51 +45 @@
         async_sess_t *client_sess;
         ddf_dev_t *dev;
-        chardev_srvs_t cds;
-        circ_buf_t cbuf;
-        uint8_t buf[ski_con_buf_size];
-        fibril_mutex_t buf_lock;
-        fibril_condvar_t buf_cv;
 } ski_con_t;
 

uspace/drv/char/sun4v-con/sun4v-con.c

@@ -1 +1 @@
 /*
  * Copyright (c) 2008 Pavel Rimsky
- * Copyright (c) 2017 Jiri Svoboda
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #include <ddi.h>
 #include <errno.h>
-#include <io/chardev_srv.h>
+#include <ipc/char.h>
 #include <stdbool.h>
 #include <thread.h>
@@ -62 +62 @@
 static input_buffer_t input_buffer;
 
-static int sun4v_con_read(chardev_srv_t *, void *, size_t, size_t *);
-static int sun4v_con_write(chardev_srv_t *, const void *, size_t, size_t *);
-
-static chardev_ops_t sun4v_con_chardev_ops = {
-        .read = sun4v_con_read,
-        .write = sun4v_con_write
-};
+static void sun4v_thread_impl(void *arg);
 
 static void sun4v_con_putchar(sun4v_con_t *con, uint8_t data)
@@ -92 +86 @@
         }
 
-        chardev_srvs_init(&con->cds);
-        con->cds.ops = &sun4v_con_chardev_ops;
-        con->cds.sarg = con;
-
         ddf_fun_set_conn_handler(fun, sun4v_con_connection);
 
@@ -105 +95 @@
         }
 
+        thread_id_t tid;
+        rc = thread_create(sun4v_thread_impl, con, "kbd_poll", &tid);
+        if (rc != EOK)
+                goto error;
+
         rc = ddf_fun_bind(fun);
         if (rc != EOK) {
@@ -136 +131 @@
 }
 
-/** Read from Sun4v console device */
-static int sun4v_con_read(chardev_srv_t *srv, void *buf, size_t size,
-    size_t *nread)
-{
-        size_t p;
-        uint8_t *bp = (uint8_t *) buf;
+/**
+ * Called regularly by the polling thread. Reads codes of all the
+ * pressed keys from the buffer.
+ */
+static void sun4v_key_pressed(sun4v_con_t *con)
+{
         char c;
 
-        while (input_buffer->read_ptr == input_buffer->write_ptr)
-                fibril_usleep(POLL_INTERVAL);
-
-        p = 0;
-        while (p < size && input_buffer->read_ptr != input_buffer->write_ptr) {
+        while (input_buffer->read_ptr != input_buffer->write_ptr) {
                 c = input_buffer->data[input_buffer->read_ptr];
                 input_buffer->read_ptr =
                     ((input_buffer->read_ptr) + 1) % INPUT_BUFFER_SIZE;
-                bp[p++] = c;
-        }
-
-        *nread = p;
-        return EOK;
-}
-
-/** Write to Sun4v console device */
-static int sun4v_con_write(chardev_srv_t *srv, const void *data, size_t size,
-    size_t *nwr)
-{
-        sun4v_con_t *con = (sun4v_con_t *) srv->srvs->sarg;
-        size_t i;
-        uint8_t *dp = (uint8_t *) data;
-
-        for (i = 0; i < size; i++)
-                sun4v_con_putchar(con, dp[i]); 
-
-        *nwr = size;
-        return EOK;
+                if (con->client_sess != NULL) {
+                        async_exch_t *exch = async_exchange_begin(con->client_sess);
+                        async_msg_1(exch, CHAR_NOTIF_BYTE, c);
+                        async_exchange_end(exch);
+                }
+                (void) c;
+        }
+}
+
+/**
+ * Thread to poll Sun4v console for keypresses.
+ */
+static void sun4v_thread_impl(void *arg)
+{
+        sun4v_con_t *con = (sun4v_con_t *) arg;
+
+        while (true) {
+                sun4v_key_pressed(con);
+                thread_usleep(POLL_INTERVAL);
+        }
 }
 
@@ -178 +169 @@
     void *arg)
 {
-        sun4v_con_t *con = (sun4v_con_t *) ddf_dev_data_get(
-            ddf_fun_get_dev((ddf_fun_t *) arg));
-
-        chardev_conn(iid, icall, &con->cds);
+        sun4v_con_t *con;
+
+        /* Answer the IPC_M_CONNECT_ME_TO call. */
+        async_answer_0(iid, EOK);
+
+        con = (sun4v_con_t *)ddf_dev_data_get(ddf_fun_get_dev((ddf_fun_t *)arg));
+
+        while (true) {
+                ipc_call_t call;
+                ipc_callid_t callid = async_get_call(&call);
+                sysarg_t method = IPC_GET_IMETHOD(call);
+
+                if (!method) {
+                        /* The other side has hung up. */
+                        async_answer_0(callid, EOK);
+                        return;
+                }
+
+                async_sess_t *sess =
+                    async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
+                if (sess != NULL) {
+                        if (con->client_sess == NULL) {
+                                con->client_sess = sess;
+                                async_answer_0(callid, EOK);
+                        } else
+                                async_answer_0(callid, ELIMIT);
+                } else {
+                        switch (method) {
+                        case CHAR_WRITE_BYTE:
+                                ddf_msg(LVL_DEBUG, "Write %" PRIun " to device\n",
+                                    IPC_GET_ARG1(call));
+                                sun4v_con_putchar(con, (uint8_t) IPC_GET_ARG1(call));
+                                async_answer_0(callid, EOK);
+                                break;
+                        default:
+                                async_answer_0(callid, EINVAL);
+                        }
+                }
+        }
 }
 

uspace/drv/char/sun4v-con/sun4v-con.h

@@ -38 +38 @@
 #include <async.h>
 #include <ddf/driver.h>
-#include <io/chardev_srv.h>
 #include <loc.h>
 #include <stdint.h>
@@ -51 +50 @@
         async_sess_t *client_sess;
         ddf_dev_t *dev;
-        chardev_srvs_t cds;
         sun4v_con_res_t res;
 } sun4v_con_t;

uspace/drv/root/virt/devices.def

@@ -26 +26 @@
 },
 {
+        .name = "null",
+        .match_id = "virtual&test1"
+},
+{
         .name = "test3",
         .match_id = "virtual&test3"

uspace/drv/test/test1/Makefile

@@ -32 +32 @@
 
 SOURCES = \
+        char.c \
         test1.c
 

uspace/drv/test/test1/test1.c

@@ -177 +177 @@
         ddf_fun_add_to_category(fun_a, "virtual");
 
-        if (str_cmp(dev_name, "test1") == 0) {
+        if (str_cmp(dev_name, "null") == 0) {
+                ddf_fun_set_ops(fun_a,  &char_device_ops);
+                ddf_fun_add_to_category(fun_a, "virt-null");
+        } else if (str_cmp(dev_name, "test1") == 0) {
                 (void) register_fun_verbose(dev,
                     "cloning myself ;-)", "clone",

uspace/drv/test/test1/test1.h

@@ -36 +36 @@
 #define NAME "test1"
 
+extern ddf_dev_ops_t char_device_ops;
+
 #endif

uspace/lib/c/Makefile

@@ -143 +143 @@
         generic/getopt.c \
         generic/adt/checksum.c \
-        generic/adt/circ_buf.c \
         generic/adt/list.c \
         generic/adt/hash_table.c \
@@ -182 +181 @@
 
 TEST_SOURCES = \
-        test/adt/circ_buf.c \
         test/fibril/timer.c \
         test/main.c \

uspace/lib/c/generic/io/chardev_srv.c

@@ -169 +169 @@
                         break;
                 default:
-                        if (srv->srvs->ops->def_handler != NULL)
-                                srv->srvs->ops->def_handler(srv, callid, &call);
-                        else
-                                async_answer_0(callid, ENOTSUP);
+                        async_answer_0(callid, EINVAL);
                 }
         }

uspace/lib/c/include/io/chardev_srv.h

@@ -61 +61 @@
         int (*read)(chardev_srv_t *, void *, size_t, size_t *);
         int (*write)(chardev_srv_t *, const void *, size_t, size_t *);
-        void (*def_handler)(chardev_srv_t *, ipc_callid_t, ipc_call_t *);
 };
 

uspace/lib/c/include/ipc/chardev.h

@@ -41 +41 @@
 typedef enum {
         CHARDEV_READ = IPC_FIRST_USER_METHOD,
-        CHARDEV_WRITE,
+        CHARDEV_WRITE
 } chardev_request_t;
-
-enum {
-        CHARDEV_LIMIT = CHARDEV_WRITE + 1
-};
 
 #endif

uspace/lib/c/include/ipc/serial_ctl.h

@@ -30 +30 @@
 #define LIBC_IPC_SERIAL_CTL_H_
 
-#include <ipc/chardev.h>
+#include <ipc/dev_iface.h>
 
 /** IPC methods for getting/setting serial communication properties
@@ -41 +41 @@
  */
 typedef enum {
-        SERIAL_GET_COM_PROPS = CHARDEV_LIMIT,
+        SERIAL_GET_COM_PROPS = DEV_FIRST_CUSTOM_METHOD,
         SERIAL_SET_COM_PROPS
 } serial_ctl_t;

uspace/lib/c/test/main.c

@@ -32 +32 @@
 PCUT_INIT
 
-PCUT_IMPORT(circ_buf);
 PCUT_IMPORT(fibril_timer);
 PCUT_IMPORT(odict);

uspace/lib/drv/Makefile

@@ -43 +43 @@
         generic/remote_hw_res.c \
         generic/remote_pio_window.c \
+        generic/remote_char_dev.c \
         generic/remote_nic.c \
         generic/remote_ieee80211.c \

uspace/lib/drv/generic/dev_iface.c

@@ -42 +42 @@
 #include "remote_hw_res.h"
 #include "remote_pio_window.h"
+#include "remote_char_dev.h"
 #include "remote_clock_dev.h"
 #include "remote_led_dev.h"
@@ -61 +62 @@
                 [HW_RES_DEV_IFACE] = &remote_hw_res_iface,
                 [PIO_WINDOW_DEV_IFACE] = &remote_pio_window_iface,
+                [CHAR_DEV_IFACE] = &remote_char_dev_iface,
                 [NIC_DEV_IFACE] = &remote_nic_iface,
                 [IEEE80211_DEV_IFACE] = &remote_ieee80211_iface,

uspace/srv/hid/input/input.c

@@ -37 +37 @@
  */
 
+#include <adt/list.h>
+#include <stdbool.h>
+#include <fibril_synch.h>
+#include <ipc/services.h>
+#include <ipc/input.h>
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <ns.h>
+#include <async.h>
+#include <errno.h>
 #include <adt/fifo.h>
-#include <adt/list.h>
-#include <async.h>
-#include <config.h>
-#include <errno.h>
-#include <fibril.h>
-#include <fibril_synch.h>
-#include <io/chardev.h>
 #include <io/console.h>
 #include <io/keycode.h>
-#include <ipc/services.h>
-#include <ipc/input.h>
 #include <loc.h>
-#include <ns.h>
-#include <stdbool.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <str_error.h>
-
-#include "input.h"
+#include <char_dev_iface.h>
+#include <fibril.h>
+#include "layout.h"
 #include "kbd.h"
 #include "kbd_port.h"
 #include "kbd_ctl.h"
-#include "layout.h"
 #include "mouse.h"
 #include "mouse_proto.h"
 #include "serial.h"
+#include "input.h"
 
 #define NUM_LAYOUTS  4
@@ -537 +536 @@
         while (true) {
                 uint8_t data;
-                size_t nread;
-
-                chardev_read(sdev->chardev, &data, sizeof(data), &nread);
-                /* XXX Handle error */
+
+                char_dev_read(sdev->sess, &data, sizeof(data));
                 kbd_push_data(sdev->kdev, data);
         }
@@ -555 +552 @@
 {
         bool match = false;
-        int rc;
 
         serial_dev_t *sdev = serial_dev_new();
@@ -563 +559 @@
         sdev->kdev->svc_id = service_id;
         
-        rc = loc_service_get_name(service_id, &sdev->kdev->svc_name);
+        int rc = loc_service_get_name(service_id, &sdev->kdev->svc_name);
         if (rc != EOK)
                 goto fail;
@@ -586 +582 @@
                 sdev->sess = loc_service_connect(service_id, INTERFACE_DDF,
                     IPC_FLAG_BLOCKING);
-
-                rc = chardev_open(sdev->sess, &sdev->chardev);
-                if (rc != EOK) {
-                        async_hangup(sdev->sess);
-                        sdev->sess = NULL;
-                        list_remove(&sdev->link);
-                        goto fail;
-                }
 
                 fid_t fid = fibril_create(serial_consumer, sdev);

uspace/srv/hid/input/port/chardev.c

@@ -35 +35 @@
  */
 
+#include <ipc/char.h>
 #include <async.h>
+#include <loc.h>
 #include <errno.h>
-#include <fibril.h>
-#include <io/chardev.h>
-#include <loc.h>
 #include <stdio.h>
 #include "../input.h"
@@ -45 +44 @@
 #include "../kbd.h"
 
-static int kbd_port_fibril(void *);
+static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
 
 static int chardev_port_init(kbd_dev_t *);
-static void chardev_port_write(uint8_t);
+static void chardev_port_write(uint8_t data);
 
 kbd_port_ops_t chardev_port = {
@@ -57 +56 @@
 static kbd_dev_t *kbd_dev;
 static async_sess_t *dev_sess;
-static chardev_t *chardev;
 
 /** List of devices to try connecting to. */
@@ -72 +70 @@
 {
         service_id_t service_id;
+        async_exch_t *exch;
         unsigned int i;
-        fid_t fid;
         int rc;
         
@@ -98 +96 @@
         }
         
-        rc = chardev_open(dev_sess, &chardev);
-        if (rc != EOK) {
-                printf("%s: Failed opening character device\n", NAME);
+        exch = async_exchange_begin(dev_sess);
+        if (exch == NULL) {
+                printf("%s: Failed starting exchange with device\n", NAME);
                 async_hangup(dev_sess);
                 return ENOMEM;
         }
         
-        fid = fibril_create(kbd_port_fibril, NULL);
-        if (fid == 0) {
-                printf("%s: Failed creating fibril\n", NAME);
-                chardev_close(chardev);
+        port_id_t port;
+        rc = async_create_callback_port(exch, INTERFACE_CHAR_CB, 0, 0,
+            kbd_port_events, NULL, &port);
+        
+        async_exchange_end(exch);
+        
+        if (rc != 0) {
+                printf("%s: Failed to create callback from device\n", NAME);
                 async_hangup(dev_sess);
-                return ENOMEM;
+                return -1;
         }
-
-        fibril_add_ready(fid);
         
         printf("%s: Found input device '%s'\n", NAME, in_devs[i]);
@@ -121 +121 @@
 static void chardev_port_write(uint8_t data)
 {
-        int rc;
-        size_t nwr;
+        async_exch_t *exch = async_exchange_begin(dev_sess);
+        if (exch == NULL) {
+                printf("%s: Failed starting exchange with device\n", NAME);
+                return;
+        }
 
-        rc = chardev_write(chardev, &data, sizeof(data), &nwr);
-        if (rc != EOK || nwr != sizeof(data)) {
-                printf("%s: Failed writing to character device\n", NAME);
-                return;
+        async_msg_1(exch, CHAR_WRITE_BYTE, data);
+        async_exchange_end(exch);
+}
+
+static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg)
+{
+        /* Ignore parameters, the connection is already opened */
+        while (true) {
+
+                ipc_call_t call;
+                ipc_callid_t callid = async_get_call(&call);
+                
+                if (!IPC_GET_IMETHOD(call)) {
+                        /* TODO: Handle hangup */
+                        return;
+                }
+
+                int retval = EOK;
+
+                switch (IPC_GET_IMETHOD(call)) {
+                case CHAR_NOTIF_BYTE:
+                        kbd_push_data(kbd_dev, IPC_GET_ARG1(call));
+                        break;
+                default:
+                        retval = ENOENT;
+                }
+                async_answer_0(callid, retval);
         }
 }
 
-static int kbd_port_fibril(void *arg)
-{
-        int rc;
-        size_t nread;
-        uint8_t b;
-
-        while (true) {
-                rc = chardev_read(chardev, &b, sizeof(b), &nread);
-                if (rc != EOK || nread != sizeof(b)) {
-                        printf("%s: Error reading data", NAME);
-                        continue;
-                }
-
-                kbd_push_data(kbd_dev, b);
-        }
-
-        return 0;
-}
 
 /**

uspace/srv/hid/input/serial.h

@@ -39 +39 @@
 
 #include <async.h>
-#include <io/chardev.h>
 #include "kbd.h"
 
@@ -46 +45 @@
         link_t link;
         async_sess_t *sess;
-        chardev_t *chardev;
 } serial_dev_t;
 

uspace/srv/hid/isdv4_tablet/isdv4.c

@@ -27 +27 @@
  */
 
+#include <char_dev_iface.h>
 #include <errno.h>
-#include <io/chardev.h>
-#include <mem.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdlib.h>
+#include <mem.h>
 #include <thread.h>
 
@@ -298 +298 @@
         bool reading = true;
         while (reading) {
-                size_t nread;
-                int rc;
-
-                rc = chardev_read(state->chardev, state->buf + state->buf_end,
-                    state->buf_size - state->buf_end, &nread);
-                if (rc != EOK && nread == 0)
+                ssize_t read = char_dev_read(state->sess, state->buf + state->buf_end,
+                    state->buf_size - state->buf_end);
+                if (read < 0)
                         return EIO;
-                state->buf_end += nread;
+                state->buf_end += read;
 
                 size_t i = 0;
@@ -360 +357 @@
         return EOK;
 }
-
-static bool write_command(chardev_t *chardev, uint8_t command)
-{
-        int rc;
-        size_t nwr;
-
-        rc = chardev_write(chardev, &command, 1, &nwr);
-        return rc == EOK;
+static bool write_command(async_sess_t *sess, uint8_t command)
+{
+        return char_dev_write(sess, &command, 1) == 1;
 }
 
@@ -373 +365 @@
     isdv4_event_fn event_fn)
 {
-        chardev_t *chardev;
-        int rc;
-
-        rc = chardev_open(sess, &chardev);
-        if (rc != EOK)
-                return rc;
-
         memset(state, 0, sizeof(isdv4_state_t));
-
         state->sess = sess;
-        state->chardev = chardev;
-
         state->buf = malloc(BUF_SIZE);
-        if (state->buf == NULL) {
-                chardev_close(chardev);
+        if (state->buf == NULL)
                 return ENOMEM;
-        }
-
         state->buf_size = BUF_SIZE;
         state->emit_event_fn = event_fn;
@@ -398 +377 @@
 int isdv4_init_tablet(isdv4_state_t *state)
 {
-        if (!write_command(state->chardev, CMD_STOP))
+        if (!write_command(state->sess, CMD_STOP))
                 return EIO;
 
@@ -404 +383 @@
 
         // FIXME: Read all possible garbage before sending commands
-        if (!write_command(state->chardev, CMD_QUERY_STYLUS))
+        if (!write_command(state->sess, CMD_QUERY_STYLUS))
                 return EIO;
 
@@ -411 +390 @@
                 return rc;
 
-        if (!write_command(state->chardev, CMD_QUERY_TOUCH))
+        if (!write_command(state->sess, CMD_QUERY_TOUCH))
                 return EIO;
 
@@ -418 +397 @@
                 return rc;
 
-        if (!write_command(state->chardev, CMD_START))
+        if (!write_command(state->sess, CMD_START))
                 return EIO;
 

uspace/srv/hid/isdv4_tablet/isdv4.h

@@ -31 +31 @@
 
 #include <async.h>
-#include <io/chardev.h>
 
 typedef struct isdv4_event isdv4_event_t;
@@ -59 +58 @@
         bool finger1_pressed; /* Reported as touch button 1 */
 
-        /** Session with the serial device */
+        /* Session to the serial device */
         async_sess_t *sess;
-        /** Character device */
-        chardev_t *chardev;
 
         /* Receive buffer state */
@@ -69 +66 @@
         size_t buf_end;
 
-        /** Callbacks */
+        /* Callbacks */
         isdv4_event_fn emit_event_fn;
 } isdv4_state_t;

uspace/srv/hid/output/port/chardev.c

@@ -30 +30 @@
  */
 
-#include <async.h>
-#include <config.h>
-#include <errno.h>
-#include <fibril_synch.h>
-#include <io/chardev.h>
-#include <loc.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <char_dev_iface.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <async.h>
+#include <fibril_synch.h>
+#include <loc.h>
+#include <errno.h>
 #include <str.h>
+#include <config.h>
 #include "../ctl/serial.h"
 #include "../output.h"
@@ -48 +48 @@
 
 static async_sess_t *sess;
-static chardev_t *chardev;
 static service_id_t serial_cat_id;
 
@@ -58 +57 @@
 {
         uint8_t byte = (uint8_t) ch;
-        size_t nwr;
-        chardev_write(chardev, &byte, 1, &nwr);
-        /* XXX Handle error */
+        char_dev_write(sess, &byte, 1); 
 }
 
 static void chardev_control_puts(const char *str)
 {
-        size_t nwr;
-        chardev_write(chardev, (void *) str, str_size(str), &nwr);
-        /* XXX Handle error */
+        char_dev_write(sess, (void *) str, str_size(str));
 }
 
@@ -131 +126 @@
                 return;
         }
-
-        rc = chardev_open(sess, &chardev);
-        if (rc != EOK) {
-                fibril_mutex_unlock(&discovery_lock);
-                printf("%s: Failed opening character device\n", NAME);
-                return;
-        }
-
         serial_init(chardev_putchar, chardev_control_puts);
 

uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.c

@@ -27 +27 @@
  */
 
+/** @addtogroup driver_serial
+ * @{
+ */
 /**
  * @file
@@ -34 +37 @@
  */
 
+#include <ddi.h>
+#include <loc.h>
+#include <ipc/char.h>
 #include <async.h>
-#include <ddi.h>
-#include <errno.h>
-#include <inttypes.h>
-#include <io/chardev_srv.h>
-#include <loc.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sysinfo.h>
+#include <errno.h>
+#include <inttypes.h>
 #include "s3c24xx_uart.h"
 
@@ -69 +72 @@
 static void s3c24xx_uart_sendb(s3c24xx_uart_t *, uint8_t);
 
-static int s3c24xx_uart_read(chardev_srv_t *, void *, size_t, size_t *);
-static int s3c24xx_uart_write(chardev_srv_t *, const void *, size_t, size_t *);
-
-static chardev_ops_t s3c24xx_uart_chardev_ops = {
-        .read = s3c24xx_uart_read,
-        .write = s3c24xx_uart_write
-};
-
 int main(int argc, char *argv[])
 {
         printf("%s: S3C24xx on-chip UART driver\n", NAME);
         
-        async_set_fallback_port_handler(s3c24xx_uart_connection, uart);
+        async_set_fallback_port_handler(s3c24xx_uart_connection, NULL);
         int rc = loc_server_register(NAME);
         if (rc != EOK) {
@@ -116 +111 @@
     void *arg)
 {
-        s3c24xx_uart_t *uart = (s3c24xx_uart_t *) arg;
-
-        chardev_conn(iid, icall, &uart->cds);
-}
-
+        /* Answer the IPC_M_CONNECT_ME_TO call. */
+        async_answer_0(iid, EOK);
+        
+        while (true) {
+                ipc_call_t call;
+                ipc_callid_t callid = async_get_call(&call);
+                sysarg_t method = IPC_GET_IMETHOD(call);
+                
+                if (!method) {
+                        /* The other side has hung up. */
+                        async_answer_0(callid, EOK);
+                        return;
+                }
+                
+                async_sess_t *sess =
+                    async_callback_receive_start(EXCHANGE_SERIALIZE, &call);
+                if (sess != NULL) {
+                        if (uart->client_sess == NULL) {
+                                uart->client_sess = sess;
+                                async_answer_0(callid, EOK);
+                        } else
+                                async_answer_0(callid, ELIMIT);
+                } else {
+                        switch (method) {
+                        case CHAR_WRITE_BYTE:
+                                printf(NAME ": write %" PRIun " to device\n",
+                                    IPC_GET_ARG1(call));
+                                s3c24xx_uart_sendb(uart, (uint8_t) IPC_GET_ARG1(call));
+                                async_answer_0(callid, EOK);
+                                break;
+                        default:
+                                async_answer_0(callid, EINVAL);
+                        }
+                }
+        }
+}
 
 static void s3c24xx_uart_irq_handler(ipc_callid_t iid, ipc_call_t *call,
     void *arg)
 {
-        int rc;
-
         (void) iid;
         (void) call;
@@ -135 +159 @@
                 uint32_t status = pio_read_32(&uart->io->uerstat);
 
-                fibril_mutex_lock(&uart->buf_lock);
-
-                rc = circ_buf_push(&uart->cbuf, &data);
-                if (rc != EOK)
-                        printf(NAME ": Buffer overrun\n");
-
-                fibril_mutex_unlock(&uart->buf_lock);
-                fibril_condvar_broadcast(&uart->buf_cv);
+                if (uart->client_sess != NULL) {
+                        async_exch_t *exch = async_exchange_begin(uart->client_sess);
+                        async_msg_1(exch, CHAR_NOTIF_BYTE, data);
+                        async_exchange_end(exch);
+                }
 
                 if (status != 0)
@@ -155 +176 @@
         sysarg_t inr;
 
-        circ_buf_init(&uart->cbuf, uart->buf, s3c24xx_uart_buf_size, 1);
-        fibril_mutex_initialize(&uart->buf_lock);
-        fibril_condvar_initialize(&uart->buf_cv);
-
         if (sysinfo_get_value("s3c24xx_uart.address.physical",
             &uart->paddr) != EOK)
@@ -171 +188 @@
 
         uart->io = vaddr;
+        uart->client_sess = NULL;
 
         printf(NAME ": device at physical address %p, inr %" PRIun ".\n",
@@ -185 +203 @@
             pio_read_32(&uart->io->ucon) & ~UCON_RX_INT_LEVEL);
 
-        chardev_srvs_init(&uart->cds);
-        uart->cds.ops = &s3c24xx_uart_chardev_ops;
-        uart->cds.sarg = uart;
-
         return EOK;
 }
@@ -202 +216 @@
 }
 
-static int s3c24xx_uart_read(chardev_srv_t *srv, void *buf, size_t size,
-    size_t *nread)
-{
-        s3c24xx_uart_t *uart = (s3c24xx_uart_t *) srv->srvs->sarg;
-        size_t p;
-        uint8_t *bp = (uint8_t *) buf;
-        int rc;
-
-        fibril_mutex_lock(&uart->buf_lock);
-
-        while (circ_buf_nused(&uart->cbuf) == 0)
-                fibril_condvar_wait(&uart->buf_cv, &uart->buf_lock);
-
-        p = 0;
-        while (p < size) {
-                rc = circ_buf_pop(&uart->cbuf, &bp[p]);
-                if (rc != EOK)
-                        break;
-                ++p;
-        }
-
-        fibril_mutex_unlock(&uart->buf_lock);
-
-        *nread = p;
-        return EOK;
-}
-
-static int s3c24xx_uart_write(chardev_srv_t *srv, const void *data, size_t size,
-    size_t *nwr)
-{
-        s3c24xx_uart_t *uart = (s3c24xx_uart_t *) srv->srvs->sarg;
-        size_t i;
-        uint8_t *dp = (uint8_t *) data;
-
-        for (i = 0; i < size; i++)
-                s3c24xx_uart_sendb(uart, dp[i]); 
-
-        *nwr = size;
-        return EOK;
-}
-
-
 /** @}
  */

uspace/srv/hw/char/s3c24xx_uart/s3c24xx_uart.h

@@ -38 +38 @@
 #define S3C24XX_UART_H_
 
-#include <adt/circ_buf.h>
+#include <stdint.h>
 #include <async.h>
-#include <fibril_synch.h>
-#include <io/chardev_srv.h>
-#include <stdint.h>
 
 /** S3C24xx UART I/O */
@@ -79 +76 @@
 #define UFCON_FIFO_ENABLE               0x01
 
-enum {
-        s3c24xx_uart_buf_size = 64
-};
 
 /** S3C24xx UART instance */
@@ -91 +85 @@
         s3c24xx_uart_io_t *io;
 
-        /** Character device service */
-        chardev_srvs_t cds;
+        /** Callback session to the client */
+        async_sess_t *client_sess;
 
         /** Service ID */
         service_id_t service_id;
-
-        /** Circular buffer */
-        circ_buf_t cbuf;
-        /** Buffer */
-        uint8_t buf[s3c24xx_uart_buf_size];
-        /** Buffer lock */
-        fibril_mutex_t buf_lock;
-        /** Signal newly added data in buffer */
-        fibril_condvar_t buf_cv;
 } s3c24xx_uart_t;
 

uspace/srv/net/slip/slip.c

@@ -40 +40 @@
 #include <inet/addr.h>
 #include <inet/iplink_srv.h>
-#include <io/chardev.h>
+#include <char_dev_iface.h>
 #include <io/log.h>
 #include <errno.h>
@@ -96 +96 @@
 }
 
-static void write_flush(chardev_t *chardev)
+static void write_flush(async_sess_t *sess)
 {
         size_t written = 0;
 
         while (slip_send_pending > 0) {
-                int rc;
-                size_t nwr;
-
-                rc = chardev_write(chardev, &slip_send_buf[written],
-                    slip_send_pending, &nwr);
-                if (rc != EOK) {
+                ssize_t size;
+
+                size = char_dev_write(sess, &slip_send_buf[written],
+                    slip_send_pending);
+                if (size < 0) {
                         log_msg(LOG_DEFAULT, LVL_ERROR,
-                            "chardev_write() returned %d", rc);
+                            "char_dev_write() returned %d",
+                            (int) size);
                         slip_send_pending = 0;
                         break;
                 }
-                written += nwr;
-                slip_send_pending -= nwr;
-        }
-}
-
-static void write_buffered(chardev_t *chardev, uint8_t ch)
+                written += size;
+                slip_send_pending -= size;
+        }
+}
+
+static void write_buffered(async_sess_t *sess, uint8_t ch)
 {
         if (slip_send_pending == sizeof(slip_send_buf))
-                write_flush(chardev);
+                write_flush(sess);
         slip_send_buf[slip_send_pending++] = ch;
 }
@@ -128 +128 @@
         log_msg(LOG_DEFAULT, LVL_DEBUG, "slip_send()");
         
-        chardev_t *chardev = (chardev_t *) srv->arg;
+        async_sess_t *sess = (async_sess_t *) srv->arg;
         uint8_t *data = sdu->data;
         
@@ -136 +136 @@
          * measure for dealing with previous possible noise on the line.
          */
-        write_buffered(chardev, SLIP_END);
+        write_buffered(sess, SLIP_END);
         
         for (size_t i = 0; i < sdu->size; i++) {
                 switch (data[i]) {
                 case SLIP_END:
-                        write_buffered(chardev, SLIP_ESC);
-                        write_buffered(chardev, SLIP_ESC_END);
+                        write_buffered(sess, SLIP_ESC);
+                        write_buffered(sess, SLIP_ESC_END);
                         break;
                 case SLIP_ESC:
-                        write_buffered(chardev, SLIP_ESC);
-                        write_buffered(chardev, SLIP_ESC_ESC);
+                        write_buffered(sess, SLIP_ESC);
+                        write_buffered(sess, SLIP_ESC_ESC);
                         break;
                 default:
-                        write_buffered(chardev, data[i]);
+                        write_buffered(sess, data[i]);
                         break;
                 }
         }
         
-        write_buffered(chardev, SLIP_END);
-        write_flush(chardev);
+        write_buffered(sess, SLIP_END);
+        write_flush(sess);
         
         return EOK;
@@ -203 +203 @@
 }
 
-static uint8_t read_buffered(chardev_t *chardev)
+static uint8_t read_buffered(async_sess_t *sess)
 {
         while (slip_recv_pending == 0) {
-                int rc;
-                size_t nread;
-
-                rc = chardev_read(chardev, slip_recv_buf,
-                    sizeof(slip_recv_buf), &nread);
-                if (rc != EOK) {
+                ssize_t size;
+
+                size = char_dev_read(sess, slip_recv_buf,
+                    sizeof(slip_recv_buf));
+                if (size < 0) {
                         log_msg(LOG_DEFAULT, LVL_ERROR,
-                            "char_dev_read() returned %d", rc);
+                            "char_dev_read() returned %d", (int) size);
+                        return SLIP_END;
                 }
-
-                if (nread == 0)
-                        return SLIP_END;
-
-                slip_recv_pending = nread;
+                slip_recv_pending = size;
                 slip_recv_read = 0;
         }
@@ -228 +224 @@
 static int slip_recv_fibril(void *arg)
 {
-        chardev_t *chardev = (chardev_t *) arg;
+        async_sess_t *sess = (async_sess_t *) arg;
         static uint8_t recv_final[SLIP_MTU];
         iplink_recv_sdu_t sdu;
@@ -238 +234 @@
         while (true) {
                 for (sdu.size = 0; sdu.size < sizeof(recv_final); /**/) {
-                        ch = read_buffered(chardev);
+                        ch = read_buffered(sess);
                         switch (ch) {
                         case SLIP_END:
@@ -250 +246 @@
 
                         case SLIP_ESC:
-                                ch = read_buffered(chardev);
+                                ch = read_buffered(sess);
                                 if (ch == SLIP_ESC_END) {
                                         recv_final[sdu.size++] = SLIP_END;
                                         break;
-                                } else if (ch == SLIP_ESC_ESC) {
+                                } else if (ch ==  SLIP_ESC_ESC) {
                                         recv_final[sdu.size++] = SLIP_ESC;
                                         break;
@@ -299 +295 @@
         async_sess_t *sess_in = NULL;
         async_sess_t *sess_out = NULL;
-        chardev_t *chardev_in = NULL;
-        chardev_t *chardev_out = NULL;
         fid_t fid;
         int rc;
@@ -342 +336 @@
                 return ENOENT;
         }
-
-        rc = chardev_open(sess_out, &chardev_out);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR,
-                    "Failed opening character device.");
-                return ENOENT;
-        }
-
-        slip_iplink.arg = chardev_out;
+        slip_iplink.arg = sess_out;
 
         sess_in = loc_service_connect(svcid, INTERFACE_DDF, 0);
@@ -361 +347 @@
         }
 
-        rc = chardev_open(sess_in, &chardev_in);
-        if (rc != EOK) {
-                log_msg(LOG_DEFAULT, LVL_ERROR,
-                    "Failed opening character device.");
-                return ENOENT;
-        }
-
         rc = loc_service_register(linkstr, &linksid);
         if (rc != EOK) {
@@ -384 +363 @@
         }
 
-        fid = fibril_create(slip_recv_fibril, chardev_in);
+        fid = fibril_create(slip_recv_fibril, sess_in);
         if (!fid) {
                 log_msg(LOG_DEFAULT, LVL_ERROR,
@@ -396 +375 @@
 
 fail:
-        chardev_close(chardev_out);
         if (sess_out)
                 async_hangup(sess_out);
-        chardev_close(chardev_in);
         if (sess_in)
                 async_hangup(sess_in);