video.c

Go to the documentation of this file.

#include <slibc.h>
#include <sys/types.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 <object.h>
#include <list.h>
#include <vfs.h>
#include <device.h>
#include <video.h>

#include <debug.h>

#define TAB_SIZE        7
#define MAX_SIZE        2000
#define MAX_COLUMN      80
#define VIDEO_BUFFER    ((char *)0xb8000)

struct info {
        char *video;
        unsigned char auto_scroll;
        char attribute;
};

off_t video_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 video_read(struct ninfo *ninfo, struct nctx *ctx, void *buf, size_t size)
{
        register int i;
        register int offset;
        struct info *info;
        char *buffer = buf;

        info = ctx->priv;

        for (i = 0; i < size && ctx->offset < ninfo->size; i ++) {
                offset = ctx->offset << 1;
                buffer[i] = info->video[offset];
                ctx->offset++;
        }

        return i;
}

int video_write(struct ninfo *ninfo, struct nctx *ctx,
                const void *buf, size_t size)
{
        register int i;
        int offset;
        int tmp;
        struct info *info;
        const char *buffer = buf;

        info = ctx->priv;

        do {
                if (ctx->offset >= ninfo->size) {
                        /* Scroll up A line */
                        tmp = MAX_SIZE - MAX_COLUMN;
                        for (i = 0; i < tmp; i++) {
                                offset = i << 1;
                                info->video[offset] =
                                        info->video[offset + (MAX_COLUMN << 1)];

                                /* Copy attribute */
                                offset++;
                                info->video[offset] =
                                        info->video[offset + (MAX_COLUMN << 1)];
                        }

                        ctx->offset -= MAX_COLUMN;

                        /* Clear last line */
                        for (i = ctx->offset; i < ninfo->size; i++) {
                                offset = i << 1;
                                info->video[offset] = 0x20;
                                info->video[offset + 1] = info->attribute;
                        }

                        /* Update the offset */
                }

                /* Write */
                for (i = 0; i < size && ctx->offset < ninfo->size; i++) {
                        if (buffer[i] == '\n') {
                                offset = ctx->offset % MAX_COLUMN;
                                ctx->offset += (MAX_COLUMN - offset);
                                continue;
                        } else if (buffer[i] == '\r') {
                                offset = ctx->offset % MAX_COLUMN;
                                ctx->offset -= offset;
                                continue;
                        } else if (buffer[i] == '\t') {
                                ctx->offset += (7 << 1);
                                continue;
                        }

                        offset = ctx->offset << 1;
                        info->video[offset] = buffer[i];
                        info->video[offset + 1] = info->attribute;
                        ctx->offset++;
                }

                size -= i;
        } while (size > 0 && info->auto_scroll);

        return i;
}

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

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

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

        info->video = VIDEO_BUFFER;
        info->auto_scroll = 1;
        info->attribute = 0x07;
        ctx->offset = 0;
        ctx->priv = info;

        return 0;
}

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

static struct ninfo_ops video_ops = {
        .lseek = video_lseek,
        .read = video_read,
        .write = video_write,
        .ioctl = video_ioctl,
        .open = video_open,
        .close = video_close,
};

int video_init(void)
{
        struct ninfo *parent;
        struct ninfo *ninfo;

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

        ninfo = vfs_new_dev_ninfo(NULL, parent,
                        "video", DEVICE_VIDEO80x25, &video_ops);
        if (!ninfo) {
                return -EFAULT;
        }

        ninfo->size = MAX_SIZE;
        return 0;
}

/* End of a file */