lunaix-os/kernel/tty/lxconsole.c

   1 #include <klibc/string.h>
   2 #include <lunaix/device.h>
   3 #include <lunaix/input.h>
   4 #include <lunaix/ioctl.h>
   5 #include <lunaix/keyboard.h>
   6 #include <lunaix/lxconsole.h>
   7 #include <lunaix/mm/pmm.h>
   8 #include <lunaix/mm/valloc.h>
   9 #include <lunaix/mm/vmm.h>
  10 #include <lunaix/sched.h>
  11 #include <lunaix/signal.h>
  12 #include <lunaix/tty/console.h>
  13 #include <lunaix/tty/tty.h>
  14
  15 static struct console lx_console;
  16
  17 int
  18 __tty_write(struct device* dev, void* buf, size_t offset, size_t len);
  19
  20 int
  21 __tty_read(struct device* dev, void* buf, size_t offset, size_t len);
  22
  23 void
  24 console_flush();
  25
  26 static waitq_t lx_reader;
  27 static volatile char ttychr;
  28
  29 static volatile pid_t fg_pgid = 0;
  30
  31 static inline void
  32 print_control_code(const char cntrl)
  33 {
  34     console_write_char('^');
  35     console_write_char(cntrl + 64);
  36 }
  37
  38 int
  39 __lxconsole_listener(struct input_device* dev)
  40 {
  41     u32_t key = dev->current_pkt.sys_code;
  42     u32_t type = dev->current_pkt.pkt_type;
  43     kbd_kstate_t state = key >> 16;
  44     ttychr = key & 0xff;
  45     key = key & 0xffff;
  46
  47     if (type == PKT_RELEASE) {
  48         goto done;
  49     }
  50
  51     if ((state & KBD_KEY_FLCTRL_HELD)) {
  52         char cntrl = (char)(ttychr | 0x20);
  53         if ('a' > cntrl || cntrl > 'z') {
  54             goto done;
  55         }
  56         ttychr = cntrl - 'a' + 1;
  57         switch (ttychr) {
  58             case TCINTR:
  59                 signal_send(-fg_pgid, _SIGINT);
  60                 print_control_code(ttychr);
  61                 break;
  62             case TCSTOP:
  63                 signal_send(-fg_pgid, _SIGSTOP);
  64                 print_control_code(ttychr);
  65                 break;
  66             default:
  67                 break;
  68         }
  69     } else if (key == KEY_PG_UP) {
  70         console_view_up();
  71         goto done;
  72     } else if (key == KEY_PG_DOWN) {
  73         console_view_down();
  74         goto done;
  75     } else if ((key & 0xff00) <= KEYPAD) {
  76         ttychr = key;
  77     } else {
  78         goto done;
  79     }
  80
  81     pwake_all(&lx_reader);
  82
  83 done:
  84     return INPUT_EVT_NEXT;
  85 }
  86
  87 int
  88 __tty_exec_cmd(struct device* dev, u32_t req, va_list args)
  89 {
  90     switch (req) {
  91         case TIOCGPGRP:
  92             return fg_pgid;
  93         case TIOCSPGRP:
  94             fg_pgid = va_arg(args, pid_t);
  95             break;
  96         case TIOCCLSBUF:
  97             fifo_clear(&lx_console.output);
  98             fifo_clear(&lx_console.input);
  99             lx_console.wnd_start = 0;
 100             lx_console.lines = 0;
 101             lx_console.output.flags |= FIFO_DIRTY;
 102             break;
 103         case TIOCFLUSH:
 104             lx_console.output.flags |= FIFO_DIRTY;
 105             console_flush();
 106             break;
 107         default:
 108             return EINVAL;
 109     }
 110     return 0;
 111 }
 112
 113 void
 114 lxconsole_init()
 115 {
 116     memset(&lx_console, 0, sizeof(lx_console));
 117     fifo_init(&lx_console.output, valloc(8192), 8192, 0);
 118     fifo_init(&lx_console.input, valloc(4096), 4096, 0);
 119
 120     lx_console.flush_timer = NULL;
 121 }
 122
 123 int
 124 __tty_write_pg(struct device* dev, void* buf, size_t offset)
 125 {
 126     return __tty_write(dev, buf, offset, PG_SIZE);
 127 }
 128
 129 int
 130 __tty_read_pg(struct device* dev, void* buf, size_t offset)
 131 {
 132     return __tty_read(dev, buf, offset, PG_SIZE);
 133 }
 134
 135 void
 136 lxconsole_spawn_ttydev()
 137 {
 138     struct device* tty_dev = device_addseq(NULL, &lx_console, "tty");
 139     tty_dev->write = __tty_write;
 140     tty_dev->write_page = __tty_write_pg;
 141     tty_dev->read = __tty_read;
 142     tty_dev->read_page = __tty_read_pg;
 143     tty_dev->exec_cmd = __tty_exec_cmd;
 144
 145     waitq_init(&lx_reader);
 146     input_add_listener(__lxconsole_listener);
 147 }
 148
 149 int
 150 __tty_write(struct device* dev, void* buf, size_t offset, size_t len)
 151 {
 152     struct console* console = (struct console*)dev->underlay;
 153     console_write(console, buf, len);
 154 }
 155
 156 int
 157 __tty_read(struct device* dev, void* buf, size_t offset, size_t len)
 158 {
 159     struct console* console = (struct console*)dev->underlay;
 160
 161     size_t count = fifo_read(&console->input, buf, len);
 162     if (count > 0 && ((char*)buf)[count - 1] == '\n') {
 163         return count;
 164     }
 165
 166     while (count < len) {
 167         pwait(&lx_reader);
 168
 169         if (ttychr < 0x1B) {
 170             // ASCII control codes
 171             switch (ttychr) {
 172                 case TCINTR:
 173                     fifo_clear(&console->input);
 174                     return 0;
 175                 case TCBS:
 176                     if (fifo_backone(&console->input)) {
 177                         console_write_char(ttychr);
 178                     }
 179                     continue;
 180                 case TCLF:
 181                 case TCCR:
 182                     goto proceed;
 183                 default:
 184                     break;
 185             }
 186             print_control_code(ttychr);
 187             continue;
 188         }
 189
 190     proceed:
 191         console_write_char(ttychr);
 192         if (!fifo_putone(&console->input, ttychr) || ttychr == '\n') {
 193             break;
 194         }
 195     }
 196     return count + fifo_read(&console->input, buf + count, len - count);
 197 }
 198
 199 void
 200 console_schedule_flush()
 201 {
 202     // TODO make the flush on-demand rather than periodic
 203 }
 204
 205 size_t
 206 __find_next_line(size_t start)
 207 {
 208     size_t p = start - 1;
 209     struct fifo_buf* buffer = &lx_console.output;
 210     do {
 211         p = (p + 1) % buffer->size;
 212     } while (p != buffer->wr_pos && ((char*)buffer->data)[p] != '\n');
 213     return p + (((char*)buffer->data)[p] == '\n');
 214 }
 215
 216 size_t
 217 __find_prev_line(size_t start)
 218 {
 219     size_t p = start - 1;
 220     struct fifo_buf* buffer = &lx_console.output;
 221     do {
 222         p--;
 223     } while (p < lx_console.wnd_start && p != buffer->wr_pos &&
 224              ((char*)buffer->data)[p] != '\n');
 225
 226     if (p > lx_console.wnd_start) {
 227         return 0;
 228     }
 229     return p + 1;
 230 }
 231
 232 void
 233 console_view_up()
 234 {
 235     struct fifo_buf* buffer = &lx_console.output;
 236     mutex_lock(&buffer->lock);
 237     fifo_set_rdptr(buffer, __find_prev_line(buffer->rd_pos));
 238     buffer->flags |= FIFO_DIRTY;
 239     mutex_unlock(&buffer->lock);
 240
 241     console_flush();
 242 }
 243
 244 void
 245 console_view_down()
 246 {
 247     struct fifo_buf* buffer = &lx_console.output;
 248     mutex_lock(&buffer->lock);
 249
 250     size_t wnd = lx_console.wnd_start;
 251     size_t p = __find_next_line(buffer->rd_pos);
 252     fifo_set_rdptr(buffer, p > wnd ? wnd : p);
 253     buffer->flags |= FIFO_DIRTY;
 254     mutex_unlock(&buffer->lock);
 255
 256     console_flush();
 257 }
 258
 259 void
 260 console_flush()
 261 {
 262     if (mutex_on_hold(&lx_console.output.lock)) {
 263         return;
 264     }
 265     if (!(lx_console.output.flags & FIFO_DIRTY)) {
 266         return;
 267     }
 268
 269     size_t rdpos_save = lx_console.output.rd_pos;
 270     tty_flush_buffer(&lx_console.output);
 271     fifo_set_rdptr(&lx_console.output, rdpos_save);
 272
 273     lx_console.output.flags &= ~FIFO_DIRTY;
 274 }
 275
 276 void
 277 console_write(struct console* console, uint8_t* data, size_t size)
 278 {
 279     struct fifo_buf* fbuf = &console->output;
 280     mutex_lock(&console->output.lock);
 281     fifo_set_rdptr(fbuf, console->wnd_start);
 282
 283     uint8_t* buffer = fbuf->data;
 284     uintptr_t ptr = fbuf->wr_pos;
 285     uintptr_t rd_ptr = fbuf->rd_pos;
 286
 287     char c;
 288     for (size_t i = 0; i < size; i++) {
 289         c = data[i];
 290         if (!c) {
 291             continue;
 292         }
 293         if (c == '\n') {
 294             console->lines++;
 295         } else if (c == '\x08') {
 296             ptr = ptr ? ptr - 1 : fbuf->size - 1;
 297             continue;
 298         }
 299         buffer[ptr] = c;
 300         ptr = (ptr + 1) % fbuf->size;
 301     }
 302
 303     fifo_set_wrptr(fbuf, ptr);
 304
 305     while (console->lines >= TTY_HEIGHT) {
 306         rd_ptr = __find_next_line(rd_ptr);
 307         console->lines--;
 308     }
 309
 310     fifo_set_rdptr(&lx_console.output, rd_ptr);
 311     console->wnd_start = rd_ptr;
 312     fbuf->flags |= FIFO_DIRTY;
 313     mutex_unlock(&fbuf->lock);
 314
 315     if (!lx_console.flush_timer) {
 316         console_flush();
 317     }
 318 }
 319
 320 void
 321 console_write_str(char* str)
 322 {
 323     console_write(&lx_console, str, strlen(str));
 324 }
 325
 326 void
 327 console_write_char(char str)
 328 {
 329     console_write(&lx_console, &str, 1);
 330 }
 331
 332 void
 333 console_start_flushing()
 334 {
 335     struct lx_timer* timer =
 336       timer_run_ms(20, console_flush, NULL, TIMER_MODE_PERIODIC);
 337     lx_console.flush_timer = timer;
 338 }