lunaix-os/kernel/lxconsole.c

   1 #include <klibc/string.h>
   2 #include <lunaix/device.h>
   3 #include <lunaix/input.h>
   4 #include <lunaix/keyboard.h>
   5 #include <lunaix/lxconsole.h>
   6 #include <lunaix/mm/pmm.h>
   7 #include <lunaix/mm/valloc.h>
   8 #include <lunaix/mm/vmm.h>
   9 #include <lunaix/sched.h>
  10 #include <lunaix/tty/console.h>
  11 #include <lunaix/tty/tty.h>
  12
  13 static struct console lx_console;
  14
  15 int
  16 __tty_write(struct device* dev, void* buf, size_t offset, size_t len);
  17
  18 int
  19 __tty_read(struct device* dev, void* buf, size_t offset, size_t len);
  20
  21 static waitq_t lx_reader;
  22 static volatile char key;
  23
  24 int
  25 __lxconsole_listener(struct input_device* dev)
  26 {
  27     uint32_t keycode = dev->current_pkt.sys_code;
  28     uint32_t type = dev->current_pkt.pkt_type;
  29     if (type == PKT_PRESS) {
  30         if (keycode == KEY_UP) {
  31             console_view_up();
  32         } else if (keycode == KEY_DOWN) {
  33             console_view_down();
  34         }
  35         goto done;
  36     }
  37     if ((keycode & 0xff00) > KEYPAD) {
  38         goto done;
  39     }
  40
  41     key = (char)(keycode & 0x00ff);
  42
  43     pwake_all(&lx_reader);
  44
  45 done:
  46     return INPUT_EVT_NEXT;
  47 }
  48
  49 void
  50 lxconsole_init()
  51 {
  52     memset(&lx_console, 0, sizeof(lx_console));
  53     fifo_init(&lx_console.output, vzalloc(8192), 8192, 0);
  54     fifo_init(&lx_console.input, valloc(4096), 4096, 0);
  55
  56     lx_console.flush_timer = NULL;
  57
  58     struct device* tty_dev = device_addseq(NULL, &lx_console, "tty");
  59     tty_dev->write = __tty_write;
  60     tty_dev->read = __tty_read;
  61
  62     waitq_init(&lx_reader);
  63     input_add_listener(__lxconsole_listener);
  64 }
  65
  66 int
  67 __tty_write(struct device* dev, void* buf, size_t offset, size_t len)
  68 {
  69     struct console* console = (struct console*)dev->underlay;
  70     console_write(console, buf, len);
  71 }
  72
  73 int
  74 __tty_read(struct device* dev, void* buf, size_t offset, size_t len)
  75 {
  76     struct console* console = (struct console*)dev->underlay;
  77
  78     size_t count = fifo_read(&console->input, buf, len);
  79     if (count > 0 && ((char*)buf)[count - 1] == '\n') {
  80         return count;
  81     }
  82
  83     while (count < len) {
  84         pwait(&lx_reader);
  85
  86         if (key == 0x08) {
  87             if (fifo_backone(&console->input)) {
  88                 console_write_char(key);
  89             }
  90             continue;
  91         }
  92         console_write_char(key);
  93         if (!fifo_putone(&console->input, key) || key == '\n') {
  94             break;
  95         }
  96     }
  97     return count + fifo_read(&console->input, buf + count, len - count);
  98 }
  99
 100 void
 101 console_schedule_flush()
 102 {
 103     // TODO make the flush on-demand rather than periodic
 104 }
 105
 106 void
 107 console_view_up()
 108 {
 109     struct fifo_buf* buffer = &lx_console.output;
 110     mutex_lock(&buffer->lock);
 111     size_t p = lx_console.erd_pos - 2;
 112     while (p < lx_console.erd_pos && p != buffer->wr_pos &&
 113            ((char*)buffer->data)[p] != '\n') {
 114         p--;
 115     }
 116     p++;
 117
 118     if (p > lx_console.erd_pos) {
 119         p = 0;
 120     }
 121
 122     buffer->flags |= FIFO_DIRTY;
 123     lx_console.erd_pos = p;
 124     mutex_unlock(&buffer->lock);
 125 }
 126
 127 size_t
 128 __find_next_line(size_t start)
 129 {
 130     size_t p = start;
 131     while (p != lx_console.output.wr_pos &&
 132            ((char*)lx_console.output.data)[p] != '\n') {
 133         p = (p + 1) % lx_console.output.size;
 134     }
 135     return p + 1;
 136 }
 137
 138 void
 139 console_view_down()
 140 {
 141     struct fifo_buf* buffer = &lx_console.output;
 142     mutex_lock(&buffer->lock);
 143
 144     lx_console.erd_pos = __find_next_line(lx_console.erd_pos);
 145     buffer->flags |= FIFO_DIRTY;
 146     mutex_unlock(&buffer->lock);
 147 }
 148
 149 void
 150 console_flush()
 151 {
 152     if (mutex_on_hold(&lx_console.output.lock)) {
 153         return;
 154     }
 155     if (!(lx_console.output.flags & FIFO_DIRTY)) {
 156         return;
 157     }
 158
 159     tty_flush_buffer(lx_console.output.data,
 160                      lx_console.erd_pos,
 161                      lx_console.output.wr_pos,
 162                      lx_console.output.size);
 163     lx_console.output.flags &= ~FIFO_DIRTY;
 164 }
 165
 166 void
 167 console_write(struct console* console, uint8_t* data, size_t size)
 168 {
 169     mutex_lock(&console->output.lock);
 170     uint8_t* buffer = console->output.data;
 171     uintptr_t ptr = console->output.wr_pos;
 172     uintptr_t rd_ptr = console->output.rd_pos;
 173
 174     char c;
 175     int lines = 0;
 176     int j = 0;
 177     for (size_t i = 0; i < size; i++) {
 178         c = data[i];
 179         if (!c) {
 180             continue;
 181         }
 182         buffer[(ptr + j) % console->output.size] = c;
 183         lines += (c == '\n');
 184         j++;
 185     }
 186
 187     size = j;
 188
 189     uintptr_t new_ptr = (ptr + size) % console->output.size;
 190     console->output.wr_pos = new_ptr;
 191
 192     if (console->lines > TTY_HEIGHT && lines > 0) {
 193         console->output.rd_pos =
 194           __find_next_line((size + rd_ptr) % console->output.size);
 195     }
 196
 197     if (new_ptr < ptr + size && new_ptr > rd_ptr) {
 198         console->output.rd_pos = new_ptr;
 199     }
 200
 201     console->lines += lines;
 202     console->erd_pos = console->output.rd_pos;
 203     console->output.flags |= FIFO_DIRTY;
 204     mutex_unlock(&console->output.lock);
 205 }
 206
 207 void
 208 console_write_str(char* str)
 209 {
 210     console_write(&lx_console, str, strlen(str));
 211 }
 212
 213 void
 214 console_write_char(char str)
 215 {
 216     console_write(&lx_console, &str, 1);
 217 }
 218
 219 void
 220 console_start_flushing()
 221 {
 222     struct lx_timer* timer =
 223       timer_run_ms(20, console_flush, NULL, TIMER_MODE_PERIODIC);
 224     lx_console.flush_timer = timer;
 225 }