console.c

Go to the documentation of this file.

/*
 * Copyright (c) 2014, Michael Müller
 * Copyright (c) 2014, Sebastian Lackner
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#include <console/console.h>
#include <memory/physmem.h>
#include <util/util.h>
#include <io/io.h>

#define VGA_WIDTH  80
#define VGA_HEIGHT 25
#define CHAR_OFFSET(x, y) ((y) * VGA_WIDTH + (x))

static uint16_t *videoTextMemory    = (uint16_t *)0xB8000;
static uint8_t  *videoFontMemory    = (uint8_t *)0xA0000;
static UNUSED uint16_t *videoIOPort = (uint16_t *)0x0463;

static uint8_t cursorX = 0;
static uint8_t cursorY = 0;

static uint8_t consoleColor = MAKE_COLOR(COLOR_WHITE, COLOR_BLACK);

static uint32_t consoleFlags = CONFLAGS_ECHO | CONFLAGS_HWCURSOR | CONFLAGS_HWCURSOR_AUTO;

static uint8_t cursorHardwareX = 0;
static uint8_t cursorHardwareY = 0;

static const char hexTable[] = "0123456789ABCDEF";

static void __consoleSetMiscOutputRegister(bool set)
{
    uint8_t value = inb(0x3CC);

    if (set)
        value |= 1;
    else
        value &= ~1;

    outb(0x3C2, value);
}

void consoleInit()
{
    /* Protect the whole VGA address space */
    physMemProtectBootEntry(0xA0000, 0xC0000 - 0xA0000);
}

void consoleClear()
{
    uint32_t x, y;
    for (y = 0; y < VGA_HEIGHT; y++)
    {
        for (x = 0; x < VGA_WIDTH; x++)
            videoTextMemory[CHAR_OFFSET(x, y)] = ' ' | (consoleColor << 8);
    }

    consoleSetCursorPos(0, 0);

    if (consoleFlags & CONFLAGS_HWCURSOR_AUTO)
        consoleSetHardwareCursor(0, 0);
}

void consoleSetColor(uint8_t color)
{
    consoleColor = color;
}

uint8_t consoleGetColor()
{
    return consoleColor;
}


uint8_t consoleGetColorForeground()
{
    return consoleColor & 15;
}

uint8_t consoleGetColorBackground()
{
    return (consoleColor >> 4) & 15;
}

void consolePutChar(char chr)
{
    bool rawMode = consoleFlags & CONFLAGS_RAW_MODE;
    if (rawMode || chr != '\n')
    {
        videoTextMemory[CHAR_OFFSET(cursorX, cursorY)] = (chr & 0xFF) | (consoleColor << 8);
        cursorX++;
    }

    if ((chr == '\n' && !rawMode) || cursorX >= VGA_WIDTH)
    {
        cursorY++;
        cursorX = 0;
    }

    if (cursorY >= VGA_HEIGHT)
    {
        if (rawMode)
            cursorY = 0;
        else
        {
            consoleScrollUp();
            cursorY = VGA_HEIGHT - 1;
        }
    }

    if (consoleFlags & CONFLAGS_HWCURSOR_AUTO)
        consoleSetHardwareCursor(cursorX, cursorY);
}

void consoleEchoChar(char chr)
{
    if (consoleFlags & CONFLAGS_ECHO)
        consolePutChar(chr);
}

void consolePutCharRaw(uint16_t chr)
{
    bool rawMode = consoleFlags & CONFLAGS_RAW_MODE;
    videoTextMemory[CHAR_OFFSET(cursorX, cursorY)] = chr;
    cursorX++;

    if ((RAW_CHAR_CHR(chr) == '\n' && !rawMode) || cursorX >= VGA_WIDTH)
    {
        cursorY++;
        cursorX = 0;
    }

    if (cursorY >= VGA_HEIGHT)
    {
        if (rawMode)
            cursorY = 0;
        else
        {
            consoleScrollUp();
            cursorY = VGA_HEIGHT - 1;
        }
    }

    if (consoleFlags & CONFLAGS_HWCURSOR_AUTO)
        consoleSetHardwareCursor(cursorX, cursorY);
}

void consoleWriteString(const char *str)
{
    while (*str)
    {
        consolePutChar(*str++);
    }
}

void consoleWriteStringLen(const char *str, size_t len)
{
    while (len)
    {
        consolePutChar(*str++);
        len--;
    }
}

void consoleWriteRawLen(const uint16_t *data, size_t count)
{
    while (count)
    {
        consolePutCharRaw(*data++);
        count--;
    }
}

void consoleWriteStringMax(const char *str, size_t len)
{
    while (len && *str)
    {
        consolePutChar(*str++);
        len--;
    }
}

void consoleWriteHex32(uint32_t value)
{
    char buf[8];
    int i;

    for (i = 7; i >= 0; i--)
    {
        buf[i] = hexTable[value & 0xF];
        value >>= 4;
    }

    consoleWriteString("0x");
    consoleWriteStringLen(buf, 8);
}

void consoleWriteInt32(uint32_t value)
{
    char buf[12];
    int i = 11;

    buf[i] = 0;
    do
    {
        buf[--i] = '0' + (value % 10);
        value /= 10;
    }
    while (value);

    consoleWriteString(buf + i);
}

void consoleWriteHex16(uint16_t value)
{
    char buf[4];
    int i;

    for (i = 3; i >= 0; i--)
    {
        buf[i] = hexTable[value & 0xF];
        value >>= 4;
    }

    consoleWriteString("0x");
    consoleWriteStringLen(buf, 4);
}

bool consoleSetCursorPos(uint8_t x, uint8_t y)
{
    if (x >= VGA_WIDTH || y >= VGA_HEIGHT)
        return false;

    cursorX = x;
    cursorY = y;

    return true;
}

uint32_t consoleGetCursorPos()
{
    return (cursorY << 16) | cursorX;
}

uint32_t consoleGetCursorPosX()
{
    return cursorX;
}

uint32_t consoleGetCursorPosY()
{
    return cursorY;
}

void consoleScrollUp()
{
    uint32_t x, y;

    for (y = 1; y < VGA_HEIGHT; y++)
    {
        for (x = 0; x < VGA_WIDTH; x++)
            videoTextMemory[CHAR_OFFSET(x, y-1)] = videoTextMemory[CHAR_OFFSET(x, y)];
    }
    for (x = 0; x < VGA_WIDTH; x++)
        videoTextMemory[CHAR_OFFSET(x, VGA_HEIGHT - 1)] = ' ' | (consoleColor << 8);
}

uint8_t consoleGetHeight()
{
    return VGA_HEIGHT;
}

uint8_t consoleGetWidth()
{
    return VGA_WIDTH;
}

uint32_t consoleGetSize()
{
    return (VGA_HEIGHT << 16) | VGA_WIDTH;
}

void consoleShowHardwareCursor(bool changed)
{
    __consoleSetMiscOutputRegister(true);

    if (consoleFlags & CONFLAGS_HWCURSOR)
    {
        /* skip these step if only the position is going to be updated */
        if (changed)
        {
            outb(0x3D4, 0x0A);
            outb(0x3D5, 0x00);
        }

        uint32_t indexPos = CHAR_OFFSET(cursorHardwareX, cursorHardwareY);

        outb(0x3D4, 0x0F);
        outb(0x3D5, indexPos & 0xFF);
        outb(0x3D4, 0x0E);
        outb(0x3D5, (indexPos >> 8) & 0xFF);
    }
    else
    {
        /* see http://www.osdever.net/FreeVGA/vga/crtcreg.htm#0A */
        outb(0x3D4, 0x0A);
        outb(0x3D5, 0x10);
    }
}

void consoleSetHardwareCursor(uint8_t x, uint8_t y)
{
    cursorHardwareX = x;
    cursorHardwareY = y;

    if (consoleFlags & CONFLAGS_HWCURSOR)
        consoleShowHardwareCursor(false);
}

uint32_t consoleGetHardwareCursor()
{
     return (cursorHardwareY << 16) | cursorHardwareX;
}

extern uint8_t vga_latin1[256][16];

void consoleSetFont()
{
    uint32_t i;

    outw(0x03ce, 0x5);
    outw(0x03ce, 0x0406);
    outw(0x03c4, 0x0402);
    outw(0x03c4, 0x0604);

    /*
     * Characters can have a size up to 8x32. The memory always has the
     * same size independent of the selected font size. The additional
     * bytes are simply not used.
     */
    for (i = 0; i < 256; i++)
        memcpy(videoFontMemory + i * 32, &vga_latin1[i], 16);

    outw(0x03c4, 0x0302);
    outw(0x03c4, 0x0204);
    outw(0x03ce, 0x1005);
    outw(0x03ce, 0x0E06);
}

void consoleSetFlags(uint32_t flags)
{
    consoleFlags = flags;
    consoleShowHardwareCursor(true);
}

uint32_t consoleGetFlags()
{
    return consoleFlags;
}

void consoleSystemFailure(const char **lines, uint32_t numArgs, uint32_t *args, struct taskContext *context)
{
    consoleSetFlags(CONFLAGS_HWCURSOR | CONFLAGS_HWCURSOR_AUTO);
    consoleSetColor(MAKE_COLOR(COLOR_WHITE, COLOR_LIGHT_BLUE));
    consoleClear();

    /* print the title and text lines */
    if (lines)
    {
        if (*lines)
        {
            size_t length = stringLength(*lines);
            consoleSetCursorPos((length < VGA_WIDTH) ? ((VGA_WIDTH - length) / 2) : 0, 2);
            consoleSetColor(MAKE_COLOR(COLOR_LIGHT_BLUE, COLOR_WHITE));
            consoleWriteString(*lines);
            consoleSetColor(MAKE_COLOR(COLOR_WHITE, COLOR_LIGHT_BLUE));
            consoleWriteString("\n\n");
            lines++;
        }

        while (*lines)
            consoleWriteString(*lines++);
        consoleWriteString("\n\n");
    }

    if (numArgs && args)
    {
        uint32_t i;
        for (i = 0; i < numArgs; i++, args++)
        {
            consoleWriteString("  Exception argument ");
            consoleWriteInt32(i);
            consoleWriteString(": ");
            consoleWriteHex32(*args);
            consoleWriteString("\n");
        }
        consoleWriteString("\n");
    }

    if (context)
    {
        consoleWriteString("  Registers:\n");
        consoleWriteString("    cr3 = ");
        consoleWriteHex32(context->cr3);
        consoleWriteString(", eip = ");
        consoleWriteHex32(context->eip);
        consoleWriteString(", efl = ");
        consoleWriteHex32(context->eflags);
        consoleWriteString("\n    eax = ");
        consoleWriteHex32(context->eax);
        consoleWriteString(", ecx = ");
        consoleWriteHex32(context->ecx);
        consoleWriteString(", edx = ");
        consoleWriteHex32(context->edx);
        consoleWriteString(", ebx = ");
        consoleWriteHex32(context->ebx);
        consoleWriteString("\n    esp = ");
        consoleWriteHex32(context->esp);
        consoleWriteString(", ebp = ");
        consoleWriteHex32(context->ebp);
        consoleWriteString(", esi = ");
        consoleWriteHex32(context->esi);
        consoleWriteString(", edi = ");
        consoleWriteHex32(context->edi);
        consoleWriteString("\n\n");

        consoleWriteString("  Segments:\n");
        consoleWriteString("    es  = ");
        consoleWriteHex32(context->es);
        consoleWriteString(", cs  = ");
        consoleWriteHex32(context->cs);
        consoleWriteString(", ss  = ");
        consoleWriteHex32(context->ss);
        consoleWriteString("\n    ds  = ");
        consoleWriteHex32(context->ds);
        consoleWriteString(", fs  = ");
        consoleWriteHex32(context->fs);
        consoleWriteString(", gs  = ");
        consoleWriteHex32(context->gs);
        consoleWriteString("\n\n");
    }

    /* halt processor, this function will never return */
    debugHalt();
}