fdc.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stddef.h> /* restricted */
#include <stdio.h>
#include <stdlib.h>
#include <string.h> /* memcpy */
#include <stdint.h> /* intptr_t */
#include <unistd.h> /* sysconf */
#include <stropts.h>
#include <stddef.h>
#include <stdarg.h>
#include <time.h>
#include <errno.h>
#include <list.h>
#include <pthread.h>
#include <semaphore.h>

#include <object.h>
#include <vfs.h>
#include <device.h>
#include <dma.h>
#include <fdc.h>
#include <fdc_ctrl.h>
#include <fdc_single.h>

#include <zone.h>
#include <page_frame.h>
#include <onetime_map.h>

#include <debug.h>
#include <util.h>

static pthread_mutex_t s_lock = PTHREAD_MUTEX_INITIALIZER;

static inline void fdc_dma_init(enum fdc_dma_dir_t dir,
                                        unsigned long address, int count)
{
        unsigned long mode;

        mode = DMA_MODE_SINGLE;

        switch (dir) {
        case FDC_DMA_READ:
                mode |= DMA_MODE_TX_WRITE;
                break;
        case FDC_DMA_WRITE:
                mode |= DMA_MODE_TX_READ;
                break;
        default:
                return;
        }

        dma_init(DMA_CH2, mode, address, count);
}

static inline int read_data(off_t offset, struct fdc_context *priv, void *buf, size_t size)
{
        int c;
        int h;
        int s;
        int ret;

        LBA_TO_CHS(offset / FD_BLKSZ, h, c, s);

        ret = fdc_seek(priv, c, h);
        if (ret < 0) {
                goto out;
        }

        ret = fdc_read_id(priv, h);
        if (ret < 0) {
                goto out;
        }

        fdc_dma_init(FDC_DMA_READ, (unsigned long)buf, size);
        ret = fdc_read_sector(priv, c, h, s);
        if (ret < 0) {
                goto out;
        }

        ret = dma_is_done(DMA_CH2);

out:
        return ret;
}

static inline int write_data(off_t offset, struct fdc_context *priv, void *buf, size_t size)
{
        int c;
        int h;
        int s;
        int ret;

        LBA_TO_CHS(offset / FD_BLKSZ, h, c, s);

        ret = fdc_seek(priv, c, h);
        if (ret < 0) {
                goto out;
        }

        fdc_dma_init(FDC_DMA_WRITE, (unsigned long)buf, size);
        ret = fdc_write_sector(priv, c, h, s);
        if (ret < 0) {
                goto out;
        }

        ret = dma_is_done(DMA_CH2);

out:
        return ret;
}

off_t fdc_lseek(struct ninfo *ninfo, struct nctx *ctx, off_t offset, int whence)
{
        pthread_mutex_lock(&s_lock);
        switch (whence) {
        case SEEK_SET:
                ctx->offset = offset;
                break;
        case SEEK_CUR:
                ctx->offset += offset;
                break;
        case SEEK_END:
                ctx->offset = ninfo->size + offset;
                break;
        default:
                pthread_mutex_unlock(&s_lock);
                return (off_t)-1;
        }

        pthread_mutex_unlock(&s_lock);
        return ctx->offset;
}

int fdc_read(struct ninfo *ninfo, struct nctx *ctx, void *buf, size_t size)
{
        struct fdc_context *priv;
        void *pma;
        char *vma;
        off_t off;
        off_t gap;
        ssize_t sz;
        char *ptr;
        int ret;

        priv = ctx->priv;

        pma = page_frame_alloc(ZONE_BASE, 1);
        if (!pma) {
                printf("Failed to allocate page frame\n");
                return -ENOMEM;
        }

        vma = onetime_map(pma);
        if (!vma) {
                printf("Failed to do onetime mapping\n");
                page_frame_free(pma);
                return -EFAULT;
        }

        pthread_mutex_lock(&s_lock);
        gap = ctx->offset % FD_BLKSZ;
        off = ctx->offset - gap;
        ptr = buf;

        do {
                ret = read_data(off, priv, pma, FD_BLKSZ);
                if (ret < 0) {
                        printf("Failed to read data\n");
                        break;
                }

                sz = FD_BLKSZ - gap;
                sz = (size > sz) ? sz : size;
                memcpy(ptr, vma + gap, sz);
                ptr += sz;
                size -= sz;
                off += FD_BLKSZ;
                gap = 0;
        } while (size > 0);

        ctx->offset += ((uint32_t)ptr - (uint32_t)buf);
        pthread_mutex_unlock(&s_lock);

        onetime_unmap(vma);
        page_frame_free(pma);
        return ((uint32_t)ptr - (uint32_t)buf);
}

int fdc_write(struct ninfo *ninfo, struct nctx *ctx,
                const void *buf, size_t size)
{
        struct fdc_context *priv;
        void *pma;
        char *vma;
        off_t off;
        off_t gap;
        size_t sz;
        char *ptr;
        int ret;

        priv = ctx->priv;

        pma = page_frame_alloc(ZONE_BASE, 1);
        if (!pma) {
                return -ENOMEM;
        }

        vma = onetime_map(pma);
        if (!vma) {
                page_frame_free(pma);
                return -EFAULT;
        }

        pthread_mutex_lock(&s_lock);
        gap = ctx->offset % FD_BLKSZ;
        off = ctx->offset - gap;
        ptr = (char *)buf;

        do {
                ret = read_data(off, priv, pma, FD_BLKSZ);
                if (ret < 0) {
                        break;
                }

                sz = FD_BLKSZ - gap;
                sz = (size > sz) ? sz : size;
                memcpy(vma + gap, ptr, sz);

                ret = write_data(off, priv, pma, FD_BLKSZ);
                if (ret < 0) {
                        break;
                }

                ptr += sz;
                size -= sz;
                off += FD_BLKSZ;
                gap = 0;
        } while (size > 0);

        ctx->offset += ((uint32_t)ptr - (uint32_t)buf);
        pthread_mutex_unlock(&s_lock);

        onetime_unmap(vma);
        page_frame_free(pma);
        return ((uint32_t)ptr - (uint32_t)buf);
}

int fdc_ioctl(struct ninfo *ninfo, struct nctx *ctx, int request, va_list va)
{
        struct fdc_context *priv;
        unsigned char *val;
        int ret;

        priv = ctx->priv;

        switch (request) {
        case I_GETINFO:
                val = va_arg(va, unsigned char *);
                pthread_mutex_lock(&s_lock);
                ret = fdc_version(priv, val);
                pthread_mutex_unlock(&s_lock);
                break;
        default:
                ret = -EINVAL;
                break;
        }

        return ret;
}

int fdc_close(struct ninfo *ninfo, struct nctx *ctx)
{
        fdc_motor_off(ctx->priv);

        pthread_mutex_lock(&s_lock);
        fdc_fini_ctrl(ctx->priv);
        pthread_mutex_unlock(&s_lock);

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

int fdc_open(struct ninfo *ninfo, struct nctx *ctx)
{
        int ret;
        struct fdc_context *priv;
        struct ninfo_dev *dev;

        dev = ninfo->priv;

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

        pthread_mutex_lock(&s_lock);
        ret = fdc_init_ctrl(priv, MINOR(dev->device));
        pthread_mutex_unlock(&s_lock);
        if (ret < 0) {
                free(priv);
                return ret;
        }

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

        fdc_motor_on(priv);
        return 0;
}

static struct ninfo_ops fdc_ops = {
        .open = fdc_open,
        .close = fdc_close,
        .lseek = fdc_lseek,
        .read = fdc_read,
        .write = fdc_write,
        .ioctl = fdc_ioctl,
};

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

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

        ninfo = vfs_new_dev_ninfo(NULL, parent, "fda", DEVICE_FDA, &fdc_ops);
        if (!ninfo) {
                return -EINVAL;
        }

        /* TODO: fdc signle 은 어디서 소멸 시키지? */
        fdc_single_init();
        return 0;
}

/* End of a file */