metal-cos/sys/dev/console.c

#include <stdbool.h>
#include <stdint.h>

#include <sys/spinlock.h>
#include <sys/kmem.h>
#include <sys/thread.h>

#include "console.h"
#include "x86/vgacons.h"
#include "x86/sercons.h"
#include "x86/debugcons.h"

Spinlock consoleLock;
Console consoles;

/*
 * Initialize console devices for debugging purposes.  At this point interrupts 
 * and device state is not initialized.
 */
void
Console_Init()
{
    VGA_Init();
    Serial_Init();
    DebugConsole_Init();

    Console_Puts("Castor Operating System\n");

    Spinlock_Init(&consoleLock, "Console Lock", SPINLOCK_TYPE_NORMAL);

    Spinlock_Init(&consoles.keyLock, "Console Keyboard Lock", SPINLOCK_TYPE_NORMAL);
    consoles.nextKey = 0;
    consoles.lastKey = 0;
}

/*
 * Setup interrupts and input devices that may not be ready
 */
void
Console_LateInit()
{
    Serial_LateInit();
}

char
Console_Getc()
{
    while (1) {
	Spinlock_Lock(&consoles.keyLock);
	if (consoles.nextKey != consoles.lastKey) {
	    char key = consoles.keyBuf[consoles.nextKey];
	    consoles.nextKey = (consoles.nextKey + 1) % CONSOLE_KEYBUF_MAXLEN;
	    Spinlock_Unlock(&consoles.keyLock);
	    return key;
	}
	Spinlock_Unlock(&consoles.keyLock);

	// Support serial debugging if interrupts are disabled
	if (Serial_HasData()) {
	    char key = Serial_Getc();
	    switch (key) {
		case '\r':
		    return '\n';
		case 0x7f:
		    return '\b';
		default:
		    return key;
	    }
	}
    }
}

void
Console_EnqueueKey(char key)
{
    Spinlock_Lock(&consoles.keyLock);
    if (((consoles.lastKey + 1) % CONSOLE_KEYBUF_MAXLEN) == consoles.lastKey) {
	Spinlock_Unlock(&consoles.keyLock);
	return;
    }
    consoles.keyBuf[consoles.lastKey] = key;
    consoles.lastKey = (consoles.lastKey + 1) % CONSOLE_KEYBUF_MAXLEN;
    Spinlock_Unlock(&consoles.keyLock);
}

void
Console_Gets(char *str, size_t n)
{
    int i;

    for (i = 0; i < (n - 1); i++)
    {
	char ch = Console_Getc();
	if (ch == '\b') {
	    if (i > 0) {
		Console_Putc(ch);
		i--;
	    }
	    i--;
	    continue;
	}
	if (ch == '\n') {
	    Console_Putc('\n');
	    str[i] = '\0';
	    return;
	}
	if (ch == '\r') {
	    Console_Putc('\n');
	    str[i] = '\0';
	    return;
	}
	if (ch == '\t') {
	    Console_Putc('\t');
	    str[i] = '\t';
	    continue;
	}
	if (ch < 0x20)
	{
	    // Unprintable character
	    continue;
	}
	Console_Putc(ch);
	str[i] = ch;
    }

    str[i+1] = '\0';
}

void
Console_Putc(char ch)
{
    Spinlock_Lock(&consoleLock);
    VGA_Putc(ch);
    Serial_Putc(ch);
    DebugConsole_Putc(ch);
    Spinlock_Unlock(&consoleLock);
}

void
Console_Puts(const char *str)
{
    Spinlock_Lock(&consoleLock);
    VGA_Puts(str);
    Serial_Puts(str);
    DebugConsole_Puts(str);
    Spinlock_Unlock(&consoleLock);
}

int
Console_Read(Handle *handle, void *buf, uint64_t off, uint64_t len)
{
    uintptr_t b = (uintptr_t)buf;
    uint64_t i;

    for (i = 0; i < len; i++)
    {
	char c = Console_Getc();
	Console_Putc(c);
	Copy_Out(&c, b+i, 1);
    }

    return len;
}

int
Console_Write(Handle *handle, void *buf, uint64_t off, uint64_t len)
{
    int i;
    uintptr_t b = (uintptr_t)buf;
    char kbuf[512];
    uint64_t nbytes = 0;

    while (len > nbytes) {
	uint64_t chunksz = len > 512 ? 512 : len;
	Copy_In(b + nbytes, &kbuf, chunksz);
	nbytes += chunksz;

	for (i = 0; i < chunksz; i++)
	    Console_Putc(kbuf[i]);
    }

    return nbytes;
}

int
Console_Flush(Handle *handle)
{
    return 0;
}

int
Console_Close(Handle *handle)
{
    Handle_Free(handle);
    return 0;
}

Handle *
Console_OpenHandle()
{
    Handle *handle = Handle_Alloc();
    if (!handle)
	return NULL;

    handle->read = &Console_Read;
    handle->write = &Console_Write;
    handle->flush = &Console_Flush;
    handle->close = &Console_Close;

    return handle;
}