Merge branch 'master' of github.com:Minep/lunaix-os

[lunaix-os.git] / lunaix-os / kernel / tty / lxconsole.c

diff --git a/lunaix-os/kernel/tty/lxconsole.c b/lunaix-os/kernel/tty/lxconsole.c
index 3404450048a9802cd638e0bdac58170db5abc902..2540077437f6befe919880b4ee5126984a073271 100644 (file)
--- a/lunaix-os/kernel/tty/lxconsole.c
+++ b/lunaix-os/kernel/tty/lxconsole.c
@@ -1,3 +1,14 @@
+/**
+ * @file lxconsole.c
+ * @author Lunaixsky (lunaxisky@qq.com)
+ * @brief Provides simple terminal support
+ * @version 0.1
+ * @date 2023-06-18
+ *
+ * @copyright Copyright (c) 2023
+ *
+ */
+

 #include <klibc/string.h>
 #include <lunaix/device.h>
 #include <lunaix/input.h>
 #include <klibc/string.h>
 #include <lunaix/device.h>
 #include <lunaix/input.h>


@@ -8,10 +19,11 @@
 #include <lunaix/mm/valloc.h>
 #include <lunaix/mm/vmm.h>
 #include <lunaix/sched.h>
 #include <lunaix/mm/valloc.h>
 #include <lunaix/mm/vmm.h>
 #include <lunaix/sched.h>

+#include <lunaix/signal.h>

 #include <lunaix/tty/console.h>
 #include <lunaix/tty/tty.h>
 
 #include <lunaix/tty/console.h>
 #include <lunaix/tty/tty.h>
 

-#include <lunaix/lxsignal.h>
+#include <hal/term.h>

 
 static struct console lx_console;
 
 
 static struct console lx_console;
 


@@ -21,28 +33,23 @@ __tty_write(struct device* dev, void* buf, size_t offset, size_t len);
 int
 __tty_read(struct device* dev, void* buf, size_t offset, size_t len);
 
 int
 __tty_read(struct device* dev, void* buf, size_t offset, size_t len);
 

+void
+console_write(struct console* console, u8_t* data, size_t size);
+

 void
 console_flush();
 
 static waitq_t lx_reader;
 void
 console_flush();
 
 static waitq_t lx_reader;

-static volatile char ttychr;

 
 static volatile pid_t fg_pgid = 0;
 
 
 static volatile pid_t fg_pgid = 0;
 

-inline void
-print_control_code(const char cntrl)
-{
-    console_write_char('^');
-    console_write_char(cntrl + 64);
-}
-

 int
 __lxconsole_listener(struct input_device* dev)
 {
 int
 __lxconsole_listener(struct input_device* dev)
 {

-    uint32_t key = dev->current_pkt.sys_code;
-    uint32_t type = dev->current_pkt.pkt_type;
+    u32_t key = dev->current_pkt.sys_code;
+    u32_t type = dev->current_pkt.pkt_type;

     kbd_kstate_t state = key >> 16;
     kbd_kstate_t state = key >> 16;

-    ttychr = key & 0xff;
+    u8_t ttychr = key & 0xff;

     key = key & 0xffff;
 
     if (type == PKT_RELEASE) {
     key = key & 0xffff;
 
     if (type == PKT_RELEASE) {


@@ -55,18 +62,6 @@ __lxconsole_listener(struct input_device* dev)
             goto done;
         }
         ttychr = cntrl - 'a' + 1;
             goto done;
         }
         ttychr = cntrl - 'a' + 1;

-        switch (ttychr) {
-            case TCINTR:
-                signal_send(-fg_pgid, _SIGINT);
-                print_control_code(ttychr);
-                break;
-            case TCSTOP:
-                signal_send(-fg_pgid, _SIGSTOP);
-                print_control_code(ttychr);
-                break;
-            default:
-                break;
-        }

     } else if (key == KEY_PG_UP) {
         console_view_up();
         goto done;
     } else if (key == KEY_PG_UP) {
         console_view_up();
         goto done;


@@ -79,6 +74,7 @@ __lxconsole_listener(struct input_device* dev)
         goto done;
     }
 
         goto done;
     }
 

+    fifo_putone(&lx_console.input, ttychr);

     pwake_all(&lx_reader);
 
 done:
     pwake_all(&lx_reader);
 
 done:


@@ -86,7 +82,7 @@ done:
 }
 
 int
 }
 
 int

-__tty_exec_cmd(struct device* dev, uint32_t req, va_list args)
+__tty_exec_cmd(struct device* dev, u32_t req, va_list args)

 {
     switch (req) {
         case TIOCGPGRP:
 {
     switch (req) {
         case TIOCGPGRP:


@@ -119,14 +115,18 @@ lxconsole_init()
     fifo_init(&lx_console.input, valloc(4096), 4096, 0);
 
     lx_console.flush_timer = NULL;
     fifo_init(&lx_console.input, valloc(4096), 4096, 0);
 
     lx_console.flush_timer = NULL;

+}

 
 

-    struct device* tty_dev = device_addseq(NULL, &lx_console, "tty");
-    tty_dev->write = __tty_write;
-    tty_dev->read = __tty_read;
-    tty_dev->exec_cmd = __tty_exec_cmd;
+int
+__tty_write_pg(struct device* dev, void* buf, size_t offset)
+{
+    return __tty_write(dev, buf, offset, PG_SIZE);
+}

 
 

-    waitq_init(&lx_reader);
-    input_add_listener(__lxconsole_listener);
+int
+__tty_read_pg(struct device* dev, void* buf, size_t offset)
+{
+    return __tty_read(dev, buf, offset, PG_SIZE);

 }
 
 int
 }
 
 int


@@ -134,6 +134,8 @@ __tty_write(struct device* dev, void* buf, size_t offset, size_t len)
 {
     struct console* console = (struct console*)dev->underlay;
     console_write(console, buf, len);
 {
     struct console* console = (struct console*)dev->underlay;
     console_write(console, buf, len);

+
+    return len;

 }
 
 int
 }
 
 int


@@ -142,40 +144,12 @@ __tty_read(struct device* dev, void* buf, size_t offset, size_t len)
     struct console* console = (struct console*)dev->underlay;
 
     size_t count = fifo_read(&console->input, buf, len);
     struct console* console = (struct console*)dev->underlay;
 
     size_t count = fifo_read(&console->input, buf, len);

-    if (count > 0 && ((char*)buf)[count - 1] == '\n') {
+    if (count > 0) {

         return count;
     }
 
         return count;
     }
 

-    while (count < len) {
-        pwait(&lx_reader);
-
-        if (ttychr < 0x1B) {
-            // ASCII control codes
-            switch (ttychr) {
-                case TCINTR:
-                    fifo_clear(&console->input);
-                    return 0;
-                case TCBS:
-                    if (fifo_backone(&console->input)) {
-                        console_write_char(ttychr);
-                    }
-                    continue;
-                case TCLF:
-                case TCCR:
-                    goto proceed;
-                default:
-                    break;
-            }
-            print_control_code(ttychr);
-            continue;
-        }
+    pwait(&lx_reader);

 
 

-    proceed:
-        console_write_char(ttychr);
-        if (!fifo_putone(&console->input, ttychr) || ttychr == '\n') {
-            break;
-        }
-    }

     return count + fifo_read(&console->input, buf + count, len - count);
 }
 
     return count + fifo_read(&console->input, buf + count, len - count);
 }
 


@@ -257,15 +231,15 @@ console_flush()
 }
 
 void
 }
 
 void

-console_write(struct console* console, uint8_t* data, size_t size)
+console_write(struct console* console, u8_t* data, size_t size)

 {
     struct fifo_buf* fbuf = &console->output;
     mutex_lock(&console->output.lock);
     fifo_set_rdptr(fbuf, console->wnd_start);
 
 {
     struct fifo_buf* fbuf = &console->output;
     mutex_lock(&console->output.lock);
     fifo_set_rdptr(fbuf, console->wnd_start);
 

-    uint8_t* buffer = fbuf->data;
-    uintptr_t ptr = fbuf->wr_pos;
-    uintptr_t rd_ptr = fbuf->rd_pos;
+    u8_t* buffer = fbuf->data;
+    ptr_t ptr = fbuf->wr_pos;
+    ptr_t rd_ptr = fbuf->rd_pos;

 
     char c;
     for (size_t i = 0; i < size; i++) {
 
     char c;
     for (size_t i = 0; i < size; i++) {


@@ -294,18 +268,22 @@ console_write(struct console* console, uint8_t* data, size_t size)
     console->wnd_start = rd_ptr;
     fbuf->flags |= FIFO_DIRTY;
     mutex_unlock(&fbuf->lock);
     console->wnd_start = rd_ptr;
     fbuf->flags |= FIFO_DIRTY;
     mutex_unlock(&fbuf->lock);

+
+    if (!lx_console.flush_timer) {
+        console_flush();
+    }

 }
 
 void
 console_write_str(char* str)
 {
 }
 
 void
 console_write_str(char* str)
 {

-    console_write(&lx_console, str, strlen(str));
+    console_write(&lx_console, (u8_t*)str, strlen(str));

 }
 
 void
 console_write_char(char str)
 {
 }
 
 void
 console_write_char(char str)
 {

-    console_write(&lx_console, &str, 1);
+    console_write(&lx_console, (u8_t*)&str, 1);

 }
 
 void
 }
 
 void


@@ -314,4 +292,32 @@ console_start_flushing()
     struct lx_timer* timer =
       timer_run_ms(20, console_flush, NULL, TIMER_MODE_PERIODIC);
     lx_console.flush_timer = timer;
     struct lx_timer* timer =
       timer_run_ms(20, console_flush, NULL, TIMER_MODE_PERIODIC);
     lx_console.flush_timer = timer;

-}
\ No newline at end of file
+}
+
+static int
+lxconsole_spawn_ttydev(struct device_def* devdef)
+{
+    struct device* tty_dev = device_allocseq(NULL, &lx_console);
+    tty_dev->ops.write = __tty_write;
+    tty_dev->ops.write_page = __tty_write_pg;
+    tty_dev->ops.read = __tty_read;
+    tty_dev->ops.read_page = __tty_read_pg;
+    tty_dev->ops.exec_cmd = __tty_exec_cmd;
+
+    waitq_init(&lx_reader);
+    input_add_listener(__lxconsole_listener);
+
+    register_device(tty_dev, &devdef->class, "vcon");
+
+    term_create(tty_dev, "FB");
+
+    return 0;
+}
+
+static struct device_def lxconsole_def = {
+    .name = "Lunaix Virtual Console",
+    .class = DEVCLASS(DEVIF_NON, DEVFN_TTY, DEV_BUILTIN),
+    .init = lxconsole_spawn_ttydev
+};
+// FIXME
+EXPORT_DEVICE(lxconsole, &lxconsole_def, load_onboot);
\ No newline at end of file