#include <klibc/string.h>
+#include <lunaix/device.h>
+#include <lunaix/input.h>
+#include <lunaix/keyboard.h>
#include <lunaix/lxconsole.h>
#include <lunaix/mm/pmm.h>
+#include <lunaix/mm/valloc.h>
#include <lunaix/mm/vmm.h>
+#include <lunaix/sched.h>
#include <lunaix/tty/console.h>
#include <lunaix/tty/tty.h>
static struct console lx_console;
-volatile int can_flush = 0;
+int
+__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);
+
+static waitq_t lx_reader;
+static volatile char key;
+
+int
+__lxconsole_listener(struct input_device* dev)
+{
+ uint32_t keycode = dev->current_pkt.sys_code;
+ uint32_t type = dev->current_pkt.pkt_type;
+ if (type == PKT_PRESS) {
+ if (keycode == KEY_UP) {
+ console_view_up();
+ } else if (keycode == KEY_DOWN) {
+ console_view_down();
+ }
+ goto done;
+ }
+ if ((keycode & 0xff00) > KEYPAD) {
+ goto done;
+ }
+
+ key = (char)(keycode & 0x00ff);
+
+ pwake_all(&lx_reader);
+
+done:
+ return INPUT_EVT_NEXT;
+}
void
lxconsole_init()
{
memset(&lx_console, 0, sizeof(lx_console));
- lx_console.buffer.data = VGA_BUFFER_VADDR + 0x1000;
- lx_console.buffer.size = 8192;
- mutex_init(&lx_console.buffer.lock);
+ fifo_init(&lx_console.output, VGA_BUFFER_VADDR + 0x1000, 8192, 0);
+ fifo_init(&lx_console.input, valloc(4096), 4096, 0);
+
+ // FIXME use valloc to allocate console buffer.
+ // In doing this, the console buffer can only be accessed from kernel mode
+ // any direct write to this buffer from user land should be purged!
// 分配控制台缓存
- for (size_t i = 0; i < PG_ALIGN(lx_console.buffer.size); i += PG_SIZE) {
+ for (size_t i = 0; i < PG_ALIGN(lx_console.output.size); i += PG_SIZE) {
uintptr_t pa = pmm_alloc_page(KERNEL_PID, 0);
vmm_set_mapping(PD_REFERENCED,
- (uintptr_t)lx_console.buffer.data + i,
+ (uintptr_t)lx_console.output.data + i,
pa,
PG_PREM_URW,
0);
}
- memset(lx_console.buffer.data, 0, lx_console.buffer.size);
-
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;
+
+ waitq_init(&lx_reader);
+ input_add_listener(__lxconsole_listener);
+}
+
+int
+__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);
+}
+
+int
+__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);
+ if (count > 0 && ((char*)buf)[count - 1] == '\n') {
+ return count;
+ }
+
+ while (count < len) {
+ pwait(&lx_reader);
+
+ if (key == 0x08) {
+ if (fifo_backone(&console->input)) {
+ console_write_char(key);
+ }
+ continue;
+ }
+ console_write_char(key);
+ if (!fifo_putone(&console->input, key) || key == '\n') {
+ break;
+ }
+ }
+ return count + fifo_read(&console->input, buf + count, len - count);
}
void
}
void
-console_view_up(struct fifo_buffer* buffer)
+console_view_up()
{
- // mutex_lock(&buffer->lock);
- size_t p = buffer->rd_pos - 2;
- while (p < buffer->rd_pos && p != buffer->wr_pos &&
+ struct fifo_buf* buffer = &lx_console.output;
+ mutex_lock(&buffer->lock);
+ size_t p = lx_console.erd_pos - 2;
+ while (p < lx_console.erd_pos && p != buffer->wr_pos &&
((char*)buffer->data)[p] != '\n') {
p--;
}
p++;
- if (p < buffer->rd_pos) {
+ if (p > lx_console.erd_pos) {
p = 0;
}
- buffer->rd_pos = p;
- // mutex_unlock(&buffer->lock);
+ buffer->flags |= FIFO_DIRTY;
+ lx_console.erd_pos = p;
+ mutex_unlock(&buffer->lock);
}
-void
-console_view_down(struct fifo_buffer* buffer)
+size_t
+__find_next_line(size_t start)
{
- // mutex_lock(&buffer->lock);
- size_t p = buffer->rd_pos;
- while (p != buffer->wr_pos && ((char*)buffer->data)[p] != '\n') {
- p = (p + 1) % buffer->size;
+ size_t p = start;
+ while (p != lx_console.output.wr_pos &&
+ ((char*)lx_console.output.data)[p] != '\n') {
+ p = (p + 1) % lx_console.output.size;
}
+ return p + 1;
+}
+
+void
+console_view_down()
+{
+ struct fifo_buf* buffer = &lx_console.output;
+ mutex_lock(&buffer->lock);
- buffer->rd_pos = p + 1;
- // mutex_unlock(&buffer->lock);
+ lx_console.erd_pos = __find_next_line(lx_console.erd_pos);
+ buffer->flags |= FIFO_DIRTY;
+ mutex_unlock(&buffer->lock);
}
void
-__flush_cb(void* arg)
+console_flush()
{
- if (mutex_on_hold(&lx_console.buffer.lock)) {
+ if (mutex_on_hold(&lx_console.output.lock)) {
return;
}
- if (!(lx_console.buffer.flags & FIFO_DIRTY)) {
+ if (!(lx_console.output.flags & FIFO_DIRTY)) {
return;
}
- size_t pos = tty_flush_buffer(lx_console.buffer.data,
- lx_console.buffer.rd_pos,
- lx_console.buffer.wr_pos,
- lx_console.buffer.size);
- lx_console.flush_timer = NULL;
- if (pos < lx_console.buffer.wr_pos) {
- console_view_down(&lx_console.buffer);
- } else {
- // clear the dirty bit only if we have flush all the data
- // that means: read pointer == write pointer
- lx_console.buffer.flags &= ~FIFO_DIRTY;
- }
+ tty_flush_buffer(lx_console.output.data,
+ lx_console.erd_pos,
+ lx_console.output.wr_pos,
+ lx_console.output.size);
+ lx_console.output.flags &= ~FIFO_DIRTY;
}
void
console_write(struct console* console, uint8_t* data, size_t size)
{
- mutex_lock(&console->buffer.lock);
- uint8_t* buffer = console->buffer.data;
- uintptr_t ptr = console->buffer.wr_pos;
- uintptr_t rd_ptr = console->buffer.rd_pos;
-
+ mutex_lock(&console->output.lock);
+ uint8_t* buffer = console->output.data;
+ uintptr_t ptr = console->output.wr_pos;
+ uintptr_t rd_ptr = console->output.rd_pos;
+
+ char c;
+ int lines = 0;
+ int j = 0;
for (size_t i = 0; i < size; i++) {
- buffer[(ptr + i) % console->buffer.size] = data[i];
+ c = data[i];
+ if (!c) {
+ continue;
+ }
+ buffer[(ptr + j) % console->output.size] = c;
+ lines += (c == '\n');
+ j++;
+ }
+
+ size = j;
+
+ uintptr_t new_ptr = (ptr + size) % console->output.size;
+ console->output.wr_pos = new_ptr;
+
+ if (console->lines > TTY_HEIGHT && lines > 0) {
+ console->output.rd_pos =
+ __find_next_line((size + rd_ptr) % console->output.size);
}
- uintptr_t new_ptr = (ptr + size) % console->buffer.size;
- console->buffer.wr_pos = new_ptr;
if (new_ptr < ptr + size && new_ptr > rd_ptr) {
- console->buffer.rd_pos = new_ptr;
+ console->output.rd_pos = new_ptr;
}
- console->buffer.flags |= FIFO_DIRTY;
- mutex_unlock(&console->buffer.lock);
+
+ console->lines += lines;
+ console->erd_pos = console->output.rd_pos;
+ console->output.flags |= FIFO_DIRTY;
+ mutex_unlock(&console->output.lock);
}
void
console_start_flushing()
{
struct lx_timer* timer =
- timer_run_ms(20, __flush_cb, NULL, TIMER_MODE_PERIODIC);
+ timer_run_ms(20, console_flush, NULL, TIMER_MODE_PERIODIC);
lx_console.flush_timer = timer;
}
\ No newline at end of file
git://scm.lunaixsky.com / lunaix-os.git / blobdiff