Subversion Repositories s80186

// Copyright Jamie Iles, 2017

//

// This file is part of s80x86.

//

// s80x86 is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// s80x86 is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with s80x86.  If not, see <http://www.gnu.org/licenses/>.

#include "bda.h"

#include "bios.h"

#include "io.h"

#include "leds.h"

#include "scancodes.h"

#include "serial.h"

#include "utils.h"

#define PS2_DATA_PORT 0x60

#define PS2_CTRL_PORT 0x61

#define PS2_CTRL_ACK (1 << 0)

#define PS2_CTRL_RX_VALID (1 << 0)

static int kbd_buffer_full(void)

{

    unsigned short tail = bda_read(kbd_buffer_tail);

    unsigned short head = bda_read(kbd_buffer_head);

    // clang-format off

    return (tail == head - 2) ||

           (head == offsetof(struct bios_data_area, kbd_buffer) &&

            tail == (offsetof(struct bios_data_area, drive_recalibration_status) - 2));

    // clang-format on

}

void noinline kbd_buffer_add(unsigned short key)

{

    if (kbd_buffer_full()) {

        led_set(LED_KBD_BUFFER_FULL);

        return;

    }

    led_clear(LED_KBD_BUFFER_FULL);

    led_set(LED_KBD_BUFFER_NON_EMPTY);

    unsigned short tail = bda_read(kbd_buffer_tail);

    unsigned circ_offset = tail - offsetof(struct bios_data_area, kbd_buffer);

    bda_write(kbd_buffer[circ_offset / sizeof(unsigned short)], key);

    tail += sizeof(unsigned short);

    if (tail >= offsetof(struct bios_data_area, drive_recalibration_status))

        tail = offsetof(struct bios_data_area, kbd_buffer);

    bda_write(kbd_buffer_tail, tail);

}

static void kbd_buffer_pop(void)

{

    unsigned short head = bda_read(kbd_buffer_head);

    head += sizeof(unsigned short);

    if (head >= offsetof(struct bios_data_area, drive_recalibration_status))

        head = offsetof(struct bios_data_area, kbd_buffer);

    bda_write(kbd_buffer_head, head);

    if (head == bda_read(kbd_buffer_tail))

        led_clear(LED_KBD_BUFFER_NON_EMPTY);

}

unsigned kbd_buffer_peek(void)

{

    unsigned short head = bda_read(kbd_buffer_head);

    unsigned short tail = bda_read(kbd_buffer_tail);

    if (head == tail)

        return 0;

    unsigned circ_offset = head - offsetof(struct bios_data_area, kbd_buffer);

    return bda_read(kbd_buffer[circ_offset / sizeof(unsigned short)]);

}

#define SCANCODE_LSHIFT 0x12

#define SCANCODE_LCTRL 0x14

#define SCANCODE_LALT 0x11

#define KBD_FLAG_LSHIFT (1 << 1)

#define KBD_FLAG_LCTRL (1 << 2)

#define KBD_FLAG_LALT (1 << 3)

static int is_modifier(unsigned char b)

{

    return b == SCANCODE_LALT || b == SCANCODE_LCTRL || b == SCANCODE_LSHIFT;

}

void modifier_key(unsigned char b, int keyup)

{

    unsigned char flags = bda_read(keyboard_flags[0]);

    unsigned char mask = 0;

    if (b == SCANCODE_LALT)

        mask = KBD_FLAG_LALT;

    if (b == SCANCODE_LSHIFT)

        mask = KBD_FLAG_LSHIFT;

    if (b == SCANCODE_LCTRL)

        mask = KBD_FLAG_LCTRL;

    if (keyup)

        flags &= ~mask;

    else

        flags |= mask;

    bda_write(keyboard_flags[0], flags);

}

static int noinline get_kbd_flags(void)

{

    return bda_read(keyboard_flags[0]);

}

static void noinline keypress(const struct keydef *map, unsigned char b)

{

    const struct keydef *def = &map[b];

    unsigned short flags = get_kbd_flags();

    if ((flags & KBD_FLAG_LSHIFT) && def->shifted)

        kbd_buffer_add(def->shifted);

    else if ((flags & KBD_FLAG_LCTRL) && def->ctrl)

        kbd_buffer_add(def->ctrl);

    else if ((flags & KBD_FLAG_LALT) && def->alt)

        kbd_buffer_add(def->alt);

    else if (def->normal)

        kbd_buffer_add(def->normal);

}

static unsigned char get_scancode(void)

{

    unsigned char b;

    do {

        b = inb(PS2_DATA_PORT);

        if (b)

            outb(PS2_CTRL_PORT, PS2_CTRL_ACK);

    } while (!b);

    return b;

}

static int is_extended(unsigned char b)

{

    return b == 0xe0;

}

static void extended_key(void)

{

    keypress(extended_keycode_map, get_scancode());

}

static void keyboard_reset(void)

{

    // Reset

    outb(PS2_DATA_PORT, 0xff);

    // Enable

    outb(PS2_DATA_PORT, 0xf4);

    // Flush FIFO

    int i;

    for (i = 0; i < 64; ++i) {

        if (!(inb(PS2_CTRL_PORT) & PS2_CTRL_RX_VALID))

            break;

        outb(PS2_CTRL_PORT, PS2_CTRL_ACK);

    }

    if (i == 64)

        putstr("Warning: failed to empty Keyboard FIFO.\n");

}

static int keyboard_poll(void)

{

    unsigned char b = inb(PS2_DATA_PORT);

    if (!b)

        return 0;

    if (b == 0xaa) {

        keyboard_reset();

        return 1;

    }

    outb(PS2_CTRL_PORT, PS2_CTRL_ACK);

    int keyup = 0;

    if (b == 0xf0) {

        keyup = 1;

        b = get_scancode();

    }

    if (is_modifier(b))

        modifier_key(b, keyup);

    else if (is_extended(b))

        extended_key();

    else if (!keyup && b < ARRAY_SIZE(keycode_map))

        keypress(keycode_map, b);

    return 1;

}

static void kbd_irq(struct callregs *regs)

{

    irq_ack();

    while (keyboard_poll())

        continue;

}

VECTOR(0x9, kbd_irq);

static void keyboard_wait(struct callregs *regs)

{

    unsigned short c;

    regs->flags &= ~CF;

    do {

        c = kbd_buffer_peek();

        if (!c) {

#ifdef SERIAL_STDIO

            serial_poll();

#endif // SERIAL_STDIO

            keyboard_poll();

        }

    } while (c == 0);

    kbd_buffer_pop();

    regs->ax.x = c;

}

static void keyboard_status(struct callregs *regs)

{

    unsigned short c;

    regs->flags &= ~CF;

#ifdef SERIAL_STDIO

    c = kbd_buffer_peek();

    if (!c)

        serial_poll();

#endif

    c = kbd_buffer_peek();

    if (c)

        regs->flags &= ~ZF;

    else

        regs->flags |= ZF;

    regs->ax.x = c;

}

static void keyboard_shift_status(struct callregs *regs)

{

    regs->flags &= ~CF;

    regs->ax.h = 0;

    regs->ax.l = bda_read(keyboard_flags[0]);

}

static void keyboard_services(struct callregs *regs)

{

    regs->flags |= CF;

    switch (regs->ax.h) {

    case 0x0: // Fallthrough

    case 0x10: keyboard_wait(regs); break;

    case 0x1: // Fallthrough

    case 0x11: keyboard_status(regs); break;

    case 0x2: keyboard_shift_status(regs); break;

    default: break;

    }

}

VECTOR(0x16, keyboard_services);

void keyboard_init(void)

{

    bda_write(keyboard_flags[0], 0);

    bda_write(keyboard_flags[1], 0);

    bda_write(kbd_buffer_tail, offsetof(struct bios_data_area, kbd_buffer));

    bda_write(kbd_buffer_head, offsetof(struct bios_data_area, kbd_buffer));

    keyboard_reset();

    irq_enable(1);

}