lunaix-os/hal/char/lxconsole.c

   1 /**
   2  * @file lxconsole.c
   3  * @author Lunaixsky (lunaxisky@qq.com)
   4  * @brief Provides simple terminal support
   5  * @version 0.1
   6  * @date 2023-06-18
   7  *
   8  * @copyright Copyright (c) 2023
   9  *
  10  */
  11
  12 #include <klibc/string.h>
  13 #include <lunaix/device.h>
  14 #include <lunaix/input.h>
  15 #include <lunaix/ioctl.h>
  16 #include <lunaix/keyboard.h>
  17 #include <lunaix/mm/pmm.h>
  18 #include <lunaix/mm/valloc.h>
  19 #include <lunaix/mm/vmm.h>
  20 #include <lunaix/sched.h>
  21 #include <lunaix/signal.h>
  22 #include <lunaix/tty/tty.h>
  23 #include <lunaix/ds/fifo.h>
  24 #include <lunaix/owloysius.h>
  25
  26 #include <hal/term.h>
  27
  28 struct console
  29 {
  30     struct termport_potens* tp_cap;
  31     struct lx_timer* flush_timer;
  32     struct fifo_buf output;
  33     struct fifo_buf input;
  34     size_t wnd_start;
  35     size_t lines;
  36 };
  37
  38 static struct console lx_console;
  39
  40 int
  41 __tty_write(struct device* dev, void* buf, size_t offset, size_t len);
  42
  43 int
  44 __tty_read(struct device* dev, void* buf, size_t offset, size_t len);
  45
  46 void
  47 console_write(struct console* console, u8_t* data, size_t size);
  48
  49 void
  50 console_flush();
  51
  52 void
  53 console_view_up();
  54
  55 void
  56 console_view_down();
  57
  58 static waitq_t lx_reader;
  59
  60 static volatile pid_t fg_pgid = 0;
  61
  62 int
  63 __lxconsole_listener(struct input_device* dev)
  64 {
  65     u32_t key = dev->current_pkt.sys_code;
  66     u32_t type = dev->current_pkt.pkt_type;
  67     kbd_kstate_t state = key >> 16;
  68     u8_t ttychr = key & 0xff;
  69     key = key & 0xffff;
  70
  71     if (type == PKT_RELEASE) {
  72         goto done;
  73     }
  74
  75     if ((state & KBD_KEY_FLCTRL_HELD)) {
  76         char cntrl = (char)(ttychr | 0x20);
  77         if ('a' > cntrl || cntrl > 'z') {
  78             goto done;
  79         }
  80         ttychr = cntrl - 'a' + 1;
  81     } else if (key == KEY_PG_UP) {
  82         console_view_up();
  83         goto done;
  84     } else if (key == KEY_PG_DOWN) {
  85         console_view_down();
  86         goto done;
  87     } else if ((key & 0xff00) <= KEYPAD) {
  88         ttychr = key;
  89     } else {
  90         goto done;
  91     }
  92
  93     fifo_putone(&lx_console.input, ttychr);
  94
  95     term_notify_data_avaliable(lx_console.tp_cap);
  96
  97     pwake_all(&lx_reader);
  98 done:
  99     return INPUT_EVT_NEXT;
 100 }
 101
 102 int
 103 __tty_write_pg(struct device* dev, void* buf, size_t offset)
 104 {
 105     return __tty_write(dev, buf, offset, PAGE_SIZE);
 106 }
 107
 108 int
 109 __tty_read_pg(struct device* dev, void* buf, size_t offset)
 110 {
 111     return __tty_read(dev, buf, offset, PAGE_SIZE);
 112 }
 113
 114 int
 115 __tty_write(struct device* dev, void* buf, size_t offset, size_t len)
 116 {
 117     struct console* console = (struct console*)dev->underlay;
 118     console_write(console, buf, len);
 119
 120     return len;
 121 }
 122
 123 int
 124 __tty_read(struct device* dev, void* buf, size_t offset, size_t len)
 125 {
 126     struct console* console = (struct console*)dev->underlay;
 127
 128     size_t count = fifo_read(&console->input, buf, len);
 129     if (count > 0) {
 130         return count;
 131     }
 132
 133     pwait(&lx_reader);
 134
 135     return count + fifo_read(&console->input, buf + count, len - count);
 136 }
 137
 138 int
 139 __tty_read_async(struct device* dev, void* buf, size_t offset, size_t len)
 140 {
 141     struct console* console = (struct console*)dev->underlay;
 142
 143     return fifo_read(&console->input, buf, len);
 144 }
 145
 146 size_t
 147 __find_next_line(size_t start)
 148 {
 149     size_t p = start - 1;
 150     struct fifo_buf* buffer = &lx_console.output;
 151     do {
 152         p = (p + 1) % buffer->size;
 153     } while (p != buffer->wr_pos && ((char*)buffer->data)[p] != '\n');
 154     return p + (((char*)buffer->data)[p] == '\n');
 155 }
 156
 157 size_t
 158 __find_prev_line(size_t start)
 159 {
 160     size_t p = start - 1;
 161     struct fifo_buf* buffer = &lx_console.output;
 162     do {
 163         p--;
 164     } while (p < lx_console.wnd_start && p != buffer->wr_pos &&
 165              ((char*)buffer->data)[p] != '\n');
 166
 167     if (p > lx_console.wnd_start) {
 168         return 0;
 169     }
 170     return p + 1;
 171 }
 172
 173 void
 174 console_view_up()
 175 {
 176     struct fifo_buf* buffer = &lx_console.output;
 177     mutex_lock(&buffer->lock);
 178     fifo_set_rdptr(buffer, __find_prev_line(buffer->rd_pos));
 179     buffer->flags |= FIFO_DIRTY;
 180     mutex_unlock(&buffer->lock);
 181
 182     console_flush();
 183 }
 184
 185 void
 186 console_view_down()
 187 {
 188     struct fifo_buf* buffer = &lx_console.output;
 189     mutex_lock(&buffer->lock);
 190
 191     size_t wnd = lx_console.wnd_start;
 192     size_t p = __find_next_line(buffer->rd_pos);
 193     fifo_set_rdptr(buffer, p > wnd ? wnd : p);
 194     buffer->flags |= FIFO_DIRTY;
 195     mutex_unlock(&buffer->lock);
 196
 197     console_flush();
 198 }
 199
 200 void
 201 console_flush()
 202 {
 203     if (mutex_on_hold(&lx_console.output.lock)) {
 204         return;
 205     }
 206     if (!(lx_console.output.flags & FIFO_DIRTY)) {
 207         return;
 208     }
 209
 210     size_t rdpos_save = lx_console.output.rd_pos;
 211     tty_flush_buffer(&lx_console.output);
 212     fifo_set_rdptr(&lx_console.output, rdpos_save);
 213
 214     lx_console.output.flags &= ~FIFO_DIRTY;
 215 }
 216
 217 void
 218 console_write(struct console* console, u8_t* data, size_t size)
 219 {
 220     struct fifo_buf* fbuf = &console->output;
 221     mutex_lock(&console->output.lock);
 222     fifo_set_rdptr(fbuf, console->wnd_start);
 223
 224     u8_t* buffer = fbuf->data;
 225     ptr_t ptr = fbuf->wr_pos;
 226     ptr_t rd_ptr = fbuf->rd_pos;
 227
 228     char c;
 229     for (size_t i = 0; i < size; i++) {
 230         c = data[i];
 231         if (!c) {
 232             continue;
 233         }
 234         if (c == '\n') {
 235             console->lines++;
 236         } else if (c == '\x08') {
 237             ptr = ptr ? ptr - 1 : fbuf->size - 1;
 238             continue;
 239         }
 240         buffer[ptr] = c;
 241         ptr = (ptr + 1) % fbuf->size;
 242     }
 243
 244     fifo_set_wrptr(fbuf, ptr);
 245
 246     while (console->lines >= TTY_HEIGHT) {
 247         rd_ptr = __find_next_line(rd_ptr);
 248         console->lines--;
 249     }
 250
 251     fifo_set_rdptr(&lx_console.output, rd_ptr);
 252     console->wnd_start = rd_ptr;
 253     fbuf->flags |= FIFO_DIRTY;
 254     mutex_unlock(&fbuf->lock);
 255
 256     if (!lx_console.flush_timer) {
 257         console_flush();
 258     }
 259 }
 260
 261 void
 262 console_write_str(char* str)
 263 {
 264     console_write(&lx_console, (u8_t*)str, strlen(str));
 265 }
 266
 267 void
 268 console_write_char(char str)
 269 {
 270     console_write(&lx_console, (u8_t*)&str, 1);
 271 }
 272
 273
 274 static void
 275 lxconsole_init()
 276 {
 277     memset(&lx_console, 0, sizeof(lx_console));
 278     fifo_init(&lx_console.output, valloc(8192), 8192, 0);
 279     fifo_init(&lx_console.input, valloc(4096), 4096, 0);
 280
 281     lx_console.flush_timer = NULL;
 282 }
 283 owloysius_fetch_init(lxconsole_init, on_earlyboot)
 284
 285 static int
 286 lxconsole_spawn_ttydev(struct device_def* devdef)
 287 {
 288     struct device* tty_dev = device_allocseq(NULL, &lx_console);
 289     tty_dev->ops.write = __tty_write;
 290     tty_dev->ops.write_page = __tty_write_pg;
 291     tty_dev->ops.read = __tty_read;
 292     tty_dev->ops.read_page = __tty_read_pg;
 293     tty_dev->ops.write_async = __tty_write;
 294     tty_dev->ops.read_async = __tty_read_async;
 295
 296     waitq_init(&lx_reader);
 297     input_add_listener(__lxconsole_listener);
 298
 299     register_device(tty_dev, &devdef->class, "vcon");
 300
 301     lx_console.tp_cap = term_attach_potens(tty_dev, NULL, "VCON");
 302
 303     return 0;
 304 }
 305
 306 static struct device_def lxconsole_def = {
 307     def_device_name("Lunaix Virtual Console"),
 308     def_device_class(LUNAIX, TTY, VTERM),
 309     def_on_load(lxconsole_spawn_ttydev)
 310 };
 311 EXPORT_DEVICE(lxconsole, &lxconsole_def, load_onboot);