keyboard.c

Go to the documentation of this file.

#include <slibc.h>
#include <sys/types.h>
#include <sys/io.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <stddef.h>
#include <stdarg.h>
#include <stropts.h>
#include <fcntl.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>

#include <object.h>
#include <list.h>
#include <vfs.h>
#include <device.h>
#include <keyboard.h>
#include <interrupt.h>
#include <isr.h>

#include <debug.h>

#define SIZE_OF_QUEUE 64

static struct {
        unsigned short buffer[SIZE_OF_QUEUE];
        off_t write_offset;
        off_t read_offset;
} s_info = {
        .buffer = { 0, },
        .write_offset = 0,
        .read_offset = 0,
};

struct info {
};

off_t keyboard_lseek(struct ninfo *ninfo, struct nctx *ctx, off_t off, int whence)
{
        switch (whence) {
        case SEEK_SET:
                break;
        case SEEK_CUR:
                off += ctx->offset;
                break;
        case SEEK_END:
                off += ninfo->size;
                break;
        default:
                return -EINVAL;
        }

        if (off < 0 || off >= ninfo->size) {
                return -EINVAL;
        }

        ctx->offset = off;
        return off;
}

int keyboard_read(struct ninfo *ninfo, struct nctx *ctx, void *buf, size_t size)
{
        int i;
        char *out = (char *)buf;

        for (i = 0; s_info.read_offset != s_info.write_offset && i < size; i++) {
                *out = (char)(s_info.buffer[s_info.read_offset] & 0x00FF);
                s_info.read_offset = (s_info.read_offset + 1) % SIZE_OF_QUEUE;
        }

        return i;
}

int keyboard_write(struct ninfo *ninfo, struct nctx *ctx,
                const void *buf, size_t size)
{
        return -EPERM;
}

int keyboard_ioctl(struct ninfo *ninfo, struct nctx *ctx, int request, va_list ap)
{
        return -ENOSYS;
}

int keyboard_open(struct ninfo *ninfo, struct nctx *ctx)
{
        struct info *info;

        info = malloc(sizeof(*info));
        if (!info) {
                return -ENOMEM;
        }

        memset(info, 0, sizeof(*info));

        ctx->offset = 0;
        ctx->priv = info;

        return 0;
}

int keyboard_close(struct ninfo *ninfo, struct nctx *ctx)
{
        free(ctx->priv);
        ctx->priv = NULL;
        return 0;
}

static struct ninfo_ops keyboard_ops = {
        .lseek = keyboard_lseek,
        .read = keyboard_read,
        .write = keyboard_write,
        .ioctl = keyboard_ioctl,
        .open = keyboard_open,
        .close = keyboard_close,
};

static int keyboard_handler(int sub_irq, void *info, void *data)
{
        static int idx = 0;
        unsigned short ch;      /* status | scancode */

        ch = inb(0x64);
        ch = (ch << 8) | inb(0x60);

        dbg_printf("[%d] keyboard: %d, %p, %d, %d\n", idx++, sub_irq, info, ch);

        s_info.buffer[s_info.write_offset] = ch;
        s_info.write_offset = (s_info.write_offset + 1) % SIZE_OF_QUEUE;
        if (s_info.write_offset == s_info.read_offset) {
                /* Discard old input */
                s_info.read_offset = (s_info.read_offset + 1) % SIZE_OF_QUEUE;
        }

        return 0;
}

int keyboard_init(void)
{
        struct ninfo *parent;
        struct ninfo *ninfo;
        int ret;

        ret = register_irq(IRQ_NR_KEYBOARD, NORMAL_PRIORITY, keyboard_handler, NULL);
        if (ret < 0) {
                return ret;
        }

        parent = vfs_get_ninfo(NULL, NULL, "/dev");
        if (!parent) {
                unregister_irq(IRQ_NR_KEYBOARD, keyboard_handler, NULL);
                return -EFAULT;
        }

        ninfo = vfs_new_dev_ninfo(NULL, parent,
                        "input", DEVICE_VIDEO80x25, &keyboard_ops);
        if (!ninfo) {
                unregister_irq(IRQ_NR_KEYBOARD, keyboard_handler, NULL);
                return -EFAULT;
        }

        ninfo->size = 0;

        return 0;
}

/* End of a file */