Changes in uspace/drv/char/sun4v-con/sun4v-con.c [dd8ab1c:7aa94304] in mainline

File:

• uspace/drv/char/sun4v-con/sun4v-con.c (modified) (7 diffs)

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 <str_error.h>
-#include <io/chardev_srv.h>
+#include <ipc/char.h>
 #include <stdbool.h>
+#include <sysinfo.h>
+#include <thread.h>
 
 #include "sun4v-con.h"
@@ -46 +47 @@
 #define POLL_INTERVAL  10000
 
-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
-};
+/*
+ * Kernel counterpart of the driver pushes characters (it has read) here.
+ * Keep in sync with the definition from
+ * kernel/arch/sparc64/src/drivers/niagara.c.
+ */
+#define INPUT_BUFFER_SIZE  ((PAGE_SIZE) - 2 * 8)
+
+typedef volatile struct {
+        uint64_t write_ptr;
+        uint64_t read_ptr;
+        char data[INPUT_BUFFER_SIZE];
+} __attribute__((packed)) __attribute__((aligned(PAGE_SIZE))) *input_buffer_t;
+
+/* virtual address of the shared buffer */
+static input_buffer_t input_buffer;
+
+static void sun4v_thread_impl(void *arg);
 
 static void sun4v_con_putchar(sun4v_con_t *con, uint8_t data)
 {
-        if (data == '\n')
-                sun4v_con_putchar(con, '\r');
-
-        while (con->output_buffer->write_ptr ==
-            (con->output_buffer->read_ptr + OUTPUT_BUFFER_SIZE - 1)
-            % OUTPUT_BUFFER_SIZE);
-
-        con->output_buffer->data[con->output_buffer->write_ptr] = data;
-        con->output_buffer->write_ptr =
-            ((con->output_buffer->write_ptr) + 1) % OUTPUT_BUFFER_SIZE;
+        (void) con;
+        (void) data;
 }
 
 /** Add sun4v console device. */
-int sun4v_con_add(sun4v_con_t *con, sun4v_con_res_t *res)
+int sun4v_con_add(sun4v_con_t *con)
 {
         ddf_fun_t *fun = NULL;
         int rc;
 
-        con->res = *res;
-        con->input_buffer = (niagara_input_buffer_t *) AS_AREA_ANY;
+        input_buffer = (input_buffer_t) AS_AREA_ANY;
 
         fun = ddf_fun_create(con->dev, fun_exposed, "a");
@@ -84 +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);
 
-        rc = physmem_map(res->in_base, 1, AS_AREA_READ | AS_AREA_WRITE,
-            (void *) &con->input_buffer);
+        sysarg_t paddr;
+        rc = sysinfo_get_value("niagara.inbuf.address", &paddr);
         if (rc != EOK) {
-                ddf_msg(LVL_ERROR, "Error mapping memory: %s", str_error_name(rc));
-                goto error;
-        }
-
-        con->output_buffer = (niagara_output_buffer_t *) AS_AREA_ANY;
-
-        rc = physmem_map(res->out_base, 1, AS_AREA_READ | AS_AREA_WRITE,
-            (void *) &con->output_buffer);
+                ddf_msg(LVL_ERROR, "niagara.inbuf.address not set (%d)", rc);
+                goto error;
+        }
+
+        rc = physmem_map(paddr, 1, AS_AREA_READ | AS_AREA_WRITE,
+            (void *) &input_buffer);
         if (rc != EOK) {
-                ddf_msg(LVL_ERROR, "Error mapping memory: %s", str_error_name(rc));
-                return rc;
-        }
+                ddf_msg(LVL_ERROR, "Error mapping memory: %d", rc);
+                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);
@@ -112 +113 @@
         }
 
-        ddf_fun_add_to_category(fun, "console");
-
         return EOK;
 error:
-        if (con->input_buffer != (niagara_input_buffer_t *) AS_AREA_ANY)
-                physmem_unmap((void *) con->input_buffer);
-
-        if (con->output_buffer != (niagara_output_buffer_t *) AS_AREA_ANY)
-                physmem_unmap((void *) con->output_buffer);
+        /* XXX Clean up thread */
+
+        if (input_buffer != (input_buffer_t) AS_AREA_ANY)
+                physmem_unmap((void *) input_buffer);
 
         if (fun != NULL)
@@ -140 +138 @@
 }
 
-/** Read from Sun4v console device */
-static int sun4v_con_read(chardev_srv_t *srv, void *buf, size_t size,
-    size_t *nread)
-{
-        sun4v_con_t *con = (sun4v_con_t *) srv->srvs->sarg;
-        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 (con->input_buffer->read_ptr == con->input_buffer->write_ptr)
-                async_usleep(POLL_INTERVAL);
-
-        p = 0;
-        while (p < size && con->input_buffer->read_ptr != con->input_buffer->write_ptr) {
-                c = con->input_buffer->data[con->input_buffer->read_ptr];
-                con->input_buffer->read_ptr =
-                    ((con->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;
+        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;
+                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);
+        }
 }
 
@@ -183 +176 @@
     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);
+                        }
+                }
+        }
 }