Changeset 7a6065c in mainline

Timestamp:

2017-11-23T11:56:31Z (7 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

221176c1

Parents:

74017ce

git-author:

Jiri Svoboda <jiri@…> (2017-11-22 19:55:36)

git-committer:

Jiri Svoboda <jiri@…> (2017-11-23 11:56:31)

Message:

Convert ipc/char.h users to chardev.

Location:

uspace

Files:

• drv/char/msim-con/msim-con.c (modified) (5 diffs)
• drv/char/msim-con/msim-con.h (modified) (2 diffs)
• drv/char/ski-con/ski-con.c (modified) (8 diffs)
• drv/char/ski-con/ski-con.h (modified) (2 diffs)
• drv/char/sun4v-con/sun4v-con.c (modified) (7 diffs)
• drv/char/sun4v-con/sun4v-con.h (modified) (2 diffs)
• lib/c/Makefile (modified) (2 diffs)
• lib/c/generic/adt/circ_buf.c (added)
• lib/c/include/adt/circ_buf.h (added)
• lib/c/test/adt/circ_buf.c (added)
• lib/c/test/main.c (modified) (1 diff)
• srv/hid/input/port/chardev.c (modified) (6 diffs)
• srv/hw/char/s3c24xx_uart/s3c24xx_uart.c (modified) (9 diffs)
• srv/hw/char/s3c24xx_uart/s3c24xx_uart.h (modified) (3 diffs)

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

@@ -37 +37 @@
 #include <ddi.h>
 #include <errno.h>
-#include <ipc/char.h>
+#include <io/chardev_srv.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[] = {
@@ -58 +66 @@
         msim_con_t *con = (msim_con_t *) arg;
         uint8_t c;
+        int rc;
+
+        fibril_mutex_lock(&con->buf_lock);
 
         c = IPC_GET_ARG2(*call);
-
-        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);
-        }
+        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);
 }
 
@@ -75 +86 @@
         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));
@@ -106 +121 @@
         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);
@@ -140 +159 @@
 }
 
+/** 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;
-
-        /* 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);
-                        }
-                }
-        }
+        msim_con_t *con = (msim_con_t *) ddf_dev_data_get(
+            ddf_fun_get_dev((ddf_fun_t *) arg));
+
+        chardev_conn(iid, icall, &con->cds);
 }
 

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 */
@@ -51 +58 @@
         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/ski-con/ski-con.c ¶

@@ -1 +1 @@
 /*
  * Copyright (c) 2005 Jakub Jermar
- * Copyright (c) 2011 Jiri Svoboda
+ * Copyright (c) 2017 Jiri Svoboda
  * All rights reserved.
  *
@@ -34 +34 @@
 #include <ddf/log.h>
 #include <errno.h>
-#include <ipc/char.h>
+#include <fibril.h>
+#include <io/chardev.h>
 #include <stdint.h>
 #include <stdlib.h>
-#include <thread.h>
 #include <stdbool.h>
 
@@ -46 +46 @@
 #define POLL_INTERVAL           10000
 
-static void ski_con_thread_impl(void *arg);
+static int ski_con_fibril(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)
 {
-        thread_id_t tid;
+        fid_t fid;
         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");
@@ -67 +79 @@
         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) {
@@ -75 +91 @@
         bound = true;
 
-        rc = thread_create(ski_con_thread_impl, con, "kbd_poll", &tid);
-        if (rc != 0) {
-                return rc;
-        }
-
+        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);
         return EOK;
 error:
@@ -102 +121 @@
 }
 
-/** Thread to poll Ski for keypresses. */
-static void ski_con_thread_impl(void *arg)
+/** Poll Ski for keypresses. */
+static int ski_con_fibril(void *arg)
 {
         int32_t c;
         ski_con_t *con = (ski_con_t *) arg;
+        int rc;
 
         while (1) {
@@ -114 +134 @@
                                 break;
 
-                        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_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);
                 }
 
-                thread_usleep(POLL_INTERVAL);
-        }
+                fibril_usleep(POLL_INTERVAL);
+        }
+
+        return 0;
 }
 
@@ -157 +182 @@
 }
 
+/** 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;
-
-        /* 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);
-                        }
-                }
-        }
+        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);
 }
 

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 */
@@ -45 +51 @@
         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) 2011 Jiri Svoboda
+ * Copyright (c) 2017 Jiri Svoboda
  * All rights reserved.
  *
@@ -36 +36 @@
 #include <ddi.h>
 #include <errno.h>
-#include <ipc/char.h>
+#include <io/chardev_srv.h>
 #include <stdbool.h>
 #include <thread.h>
@@ -62 +62 @@
 static input_buffer_t input_buffer;
 
-static void sun4v_thread_impl(void *arg);
+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_con_putchar(sun4v_con_t *con, uint8_t data)
@@ -86 +92 @@
         }
 
+        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);
 
@@ -94 +104 @@
                 goto error;
         }
-
-        thread_id_t tid;
-        rc = thread_create(sun4v_thread_impl, con, "kbd_poll", &tid);
-        if (rc != EOK)
-                goto error;
 
         rc = ddf_fun_bind(fun);
@@ -131 +136 @@
 }
 
-/**
- * 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)
+/** 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;
         char c;
 
-        while (input_buffer->read_ptr != input_buffer->write_ptr) {
+        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) {
                 c = input_buffer->data[input_buffer->read_ptr];
                 input_buffer->read_ptr =
                     ((input_buffer->read_ptr) + 1) % INPUT_BUFFER_SIZE;
-                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;
+                bp[p++] = c;
         }
+
+        *nread = p;
+        return EOK;
 }
 
-/**
- * Thread to poll Sun4v console for keypresses.
- */
-static void sun4v_thread_impl(void *arg)
+/** 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 *) arg;
+        sun4v_con_t *con = (sun4v_con_t *) srv->srvs->sarg;
+        size_t i;
+        uint8_t *dp = (uint8_t *) data;
 
-        while (true) {
-                sun4v_key_pressed(con);
-                thread_usleep(POLL_INTERVAL);
-        }
+        for (i = 0; i < size; i++)
+                sun4v_con_putchar(con, dp[i]); 
+
+        *nwr = size;
+        return EOK;
 }
 
@@ -169 +178 @@
     void *arg)
 {
-        sun4v_con_t *con;
+        sun4v_con_t *con = (sun4v_con_t *) ddf_dev_data_get(
+            ddf_fun_get_dev((ddf_fun_t *) arg));
 
-        /* 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);
-                        }
-                }
-        }
+        chardev_conn(iid, icall, &con->cds);
 }
 

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>
@@ -50 +51 @@
         async_sess_t *client_sess;
         ddf_dev_t *dev;
+        chardev_srvs_t cds;
         sun4v_con_res_t res;
 } sun4v_con_t;

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 \
@@ -181 +182 @@
 
 TEST_SOURCES = \
+        test/adt/circ_buf.c \
         test/fibril/timer.c \
         test/main.c \

uspace/lib/c/test/main.c ¶

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

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

@@ -35 +35 @@
  */
 
-#include <ipc/char.h>
 #include <async.h>
+#include <errno.h>
+#include <fibril.h>
+#include <io/chardev.h>
 #include <loc.h>
-#include <errno.h>
 #include <stdio.h>
 #include "../input.h"
@@ -44 +45 @@
 #include "../kbd.h"
 
-static void kbd_port_events(ipc_callid_t iid, ipc_call_t *icall, void *arg);
+static int kbd_port_fibril(void *);
 
 static int chardev_port_init(kbd_dev_t *);
-static void chardev_port_write(uint8_t data);
+static void chardev_port_write(uint8_t);
 
 kbd_port_ops_t chardev_port = {
@@ -56 +57 @@
 static kbd_dev_t *kbd_dev;
 static async_sess_t *dev_sess;
+static chardev_t *chardev;
 
 /** List of devices to try connecting to. */
@@ -70 +72 @@
 {
         service_id_t service_id;
-        async_exch_t *exch;
         unsigned int i;
+        fid_t fid;
         int rc;
         
@@ -96 +98 @@
         }
         
-        exch = async_exchange_begin(dev_sess);
-        if (exch == NULL) {
-                printf("%s: Failed starting exchange with device\n", NAME);
+        rc = chardev_open(dev_sess, &chardev);
+        if (rc != EOK) {
+                printf("%s: Failed opening character device\n", NAME);
                 async_hangup(dev_sess);
                 return ENOMEM;
         }
         
-        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);
+        fid = fibril_create(kbd_port_fibril, NULL);
+        if (fid == 0) {
+                printf("%s: Failed creating fibril\n", NAME);
+                chardev_close(chardev);
                 async_hangup(dev_sess);
-                return -1;
+                return ENOMEM;
         }
+
+        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)
 {
-        async_exch_t *exch = async_exchange_begin(dev_sess);
-        if (exch == NULL) {
-                printf("%s: Failed starting exchange with device\n", NAME);
+        int rc;
+        size_t nwr;
+
+        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/hw/char/s3c24xx_uart/s3c24xx_uart.c ¶

@@ -27 +27 @@
  */
 
-/** @addtogroup driver_serial
- * @{
- */
 /**
  * @file
@@ -37 +34 @@
  */
 
+#include <async.h>
 #include <ddi.h>
+#include <errno.h>
+#include <inttypes.h>
+#include <io/chardev_srv.h>
 #include <loc.h>
-#include <ipc/char.h>
-#include <async.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sysinfo.h>
-#include <errno.h>
-#include <inttypes.h>
 #include "s3c24xx_uart.h"
 
@@ -72 +69 @@
 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, NULL);
+        async_set_fallback_port_handler(s3c24xx_uart_connection, uart);
         int rc = loc_server_register(NAME);
         if (rc != EOK) {
@@ -111 +116 @@
     void *arg)
 {
-        /* 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);
-                        }
-                }
-        }
-}
+        s3c24xx_uart_t *uart = (s3c24xx_uart_t *) arg;
+
+        chardev_conn(iid, icall, &uart->cds);
+}
+
 
 static void s3c24xx_uart_irq_handler(ipc_callid_t iid, ipc_call_t *call,
     void *arg)
 {
+        int rc;
+
         (void) iid;
         (void) call;
@@ -159 +135 @@
                 uint32_t status = pio_read_32(&uart->io->uerstat);
 
-                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);
-                }
+                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 (status != 0)
@@ -176 +155 @@
         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)
@@ -188 +171 @@
 
         uart->io = vaddr;
-        uart->client_sess = NULL;
 
         printf(NAME ": device at physical address %p, inr %" PRIun ".\n",
@@ -203 +185 @@
             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;
 }
@@ -216 +202 @@
 }
 
+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 <async.h>
+#include <fibril_synch.h>
+#include <io/chardev_srv.h>
 #include <stdint.h>
-#include <async.h>
 
 /** S3C24xx UART I/O */
@@ -76 +79 @@
 #define UFCON_FIFO_ENABLE               0x01
 
+enum {
+        s3c24xx_uart_buf_size = 64
+};
 
 /** S3C24xx UART instance */
@@ -85 +91 @@
         s3c24xx_uart_io_t *io;
 
-        /** Callback session to the client */
-        async_sess_t *client_sess;
+        /** Character device service */
+        chardev_srvs_t cds;
 
         /** 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;