serial.c

Go to the documentation of this file.

#include <slibc.h>
#include <sys/types.h>
#include <sys/io.h>
#include <stdio.h>
#include <errno.h>
#include <stdarg.h>
#include <stdlib.h>
#include <stddef.h>
#include <assert.h>

#include <list.h>

#include <object.h>
#include <vfs.h>
#include <device.h>
#include <serial.h>
#include <interrupt.h>
#include <isr.h>

#include <debug.h>

static unsigned int COM[] = { 0x3F8, 0x2F8, 0x3E8, 0x2E8 };
static LIST_HEAD(s_serial);

struct context {
        int setup;
        int parity;
        int stop;
        int data;
        int baudrate;
        int validate;
};

enum port_offset {
        DATA = 0x00, 
        INTR_ENABLE = 0x01, 
        BAUD_LO = 0x00, 
        BAUD_HI = 0x01, 
        FIFO = 0x02, 
        LINE_CTRL = 0x03, 
        MODEM_CTRL = 0x04, 
        LINE_STATUS = 0x05, 
        MODEM_STATUS = 0x06, 
        SCRATCH = 0x07, 
};

#define DATA5 0x00
#define DATA6 0x01
#define DATA7 0x02
#define DATA8 0x03

#define STOPBITS1 0x00
#define STOPBITS2 0x01

#define NO_PARITY 0x00
#define ODD_PARITY 0x01
#define EVEN_PARITY 0x02

#define SERIAL_MAX_SPEED 115200

enum IER {
        RX = 0x01, 
        TX = 0x02, 
        RX_STAT = 0x04, /*< Enable Receiver Line Status Interrupt */
        MODEM_STAT = 0x08, 
        SLEEP_MODE = 0x10, 
        LOW_POWER = 0x20, 
};

static int serial_isr(int sub_irq, void *info, void *data)
{
        //printf("%s\n", __func__);
        return 0;
}

static inline void apply_setup(struct ninfo *ninfo, struct nctx *ctx)
{
        struct ninfo_dev *dev;
        struct context *priv;
        unsigned char value;
        int divisor;
        int id;

        dev = ninfo->priv;
        priv = ctx->priv;

        id = MINOR(dev->device);

        outb(COM[id] + 1, 0x00);

        divisor = SERIAL_MAX_SPEED / priv->baudrate;
        outb(COM[id] + 3, 0x80); 
        outb(COM[id] + 0, (unsigned char)divisor);
        outb(COM[id] + 1, (unsigned char)(divisor>>4));

        value = priv->data & 0x03;
        value |= ((priv->stop & 0x1) << 2);
        value |= ((priv->parity & 0x07) << 3);
        outb(COM[id] + 3, value);

        outb(COM[id] + 4, RX | TX | MODEM_STAT);
}

int serial_open(struct ninfo *ninfo, struct nctx *ctx)
{
        int id;
        struct ninfo_dev *dev;
        struct context *priv;
        int ret;
        int irq;

        dev = ninfo->priv;

        id = MINOR(dev->device);
        if (id > (sizeof(COM) / sizeof(COM[0]))) {
                return -ENODEV;
        }

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

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

        irq = (id % 2) ? IRQ_NR_SERIAL_ODD : IRQ_NR_SERIAL_EVEN;
        ret = register_irq(irq, NORMAL_PRIORITY, serial_isr, NULL);
        if (ret < 0) {
                free(priv);
                return ret;
        }

        return 0;
}

int serial_read(struct ninfo *ninfo, struct nctx *ctx, void *buf, size_t size)
{
        struct context *priv;

        priv = ctx->priv;
        if (priv->setup) {
                return -EBUSY;
        }

        /* READ: inb(COM[ctx->id]) */
        return 0;
}

int serial_write(struct ninfo *ninfo, struct nctx *ctx,
                const void *buf, size_t size)
{
        struct context *priv;
        priv = ctx->priv;

        if (priv->setup) {
                return -EBUSY;
        }

        /* WRITE: outb(COM[ctx->id], buffer[0]) */
        return 0;
}

int serial_ioctl(struct ninfo *ninfo, struct nctx *ctx, int request, va_list va)
{
        struct context *priv;

        priv = ctx->priv;

        switch (request) {
        case SERIAL_CMD_ENTER_SETUP:
                if (!priv->setup) {
                        priv->setup = 1;
                        priv->validate = 0;
                }
                break;
        case SERIAL_CMD_BAUDRATE:
                priv->baudrate = va_arg(va, int);
                priv->validate |= 0x01;
                break;
        case SERIAL_CMD_PARITY:
                priv->parity = va_arg(va, int);
                priv->validate |= 0x02;
                break;
        case SERIAL_CMD_STOP:
                priv->stop = va_arg(va, int);
                priv->validate |= 0x04;
                break;
        case SERIAL_CMD_DATA:
                priv->data = va_arg(va, int);
                priv->validate |= 0x08;
                break;
        case SERIAL_CMD_LEAVE_SETUP:
                if (priv->setup) {
                        if (priv->validate == 0x0F) {
                                apply_setup(ninfo, ctx);
                        }

                        priv->setup = 0;
                }
                break;
        default:
                return -EINVAL;
        }

        return 0;
}

int serial_close(struct ninfo *ninfo, struct nctx *ctx)
{
        struct ninfo_dev *dev;
        int irq;
        int ret;

        dev = ninfo->priv;
        //priv = ctx->priv;

        irq = (MINOR(dev->device) % 2) ? IRQ_NR_SERIAL_ODD : IRQ_NR_SERIAL_EVEN;

        ret = unregister_irq(irq, serial_isr, NULL);

        free(ctx->priv);
        ctx->priv = NULL;
        return ret;
}

static struct ninfo_ops serial_ops = {
        .open = serial_open,
        .read = serial_read,
        .write = serial_write,
        .ioctl = serial_ioctl,
        .close = serial_close,
};

int serial_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,
                        "com1", DEVICE_COM1, &serial_ops);
        if (!ninfo) {
                return -EFAULT;
        }

        ninfo = vfs_new_dev_ninfo(NULL, parent,
                        "com2", DEVICE_COM2, &serial_ops);
        if (!ninfo) {
                goto out;
        }

        ninfo = vfs_new_dev_ninfo(NULL, parent,
                        "com3", DEVICE_COM3, &serial_ops);
        if (!ninfo) {
                goto out;
        }

        ninfo = vfs_new_dev_ninfo(NULL, parent,
                        "com4", DEVICE_COM4, &serial_ops);
        if (!ninfo) {
                goto out;
        }

out:
        return 0;
}

/* End of a file */