fdc_single.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <semaphore.h>
#include <errno.h>
#include <assert.h>

#include <isr.h>
#include <interrupt.h>
#include <list.h>
#include <fdc.h>
#include <fdc_ctrl.h>

#include <ston.h>
#include <fdc_single.h>

#include <debug.h>

struct fdc_key {
        enum base_address ctrl;
        enum drive_letter drv;
};

struct fdc_single {
        sem_t sem;
        int initiated;
        struct fdc_key key;
};

static struct ston *s_ston;

static int fdc_isr(int sub_irq, void *info, void *data)
{
        struct fdc_single *single = data;
        sem_t sem;

        sem = fdc_single_sem(single);
        assert(sem && "Invalid sem");
        sem_post(&sem);

        return 0;
}

static void *create(const void *_key)
{
        const struct fdc_key *key;
        struct fdc_single *single;
        unsigned long flags;
        int ret;

        key = _key;

        single = malloc(sizeof(*single));
        if (!single) {
                return NULL;
        }

        single->key.ctrl = key->ctrl;
        single->key.drv = key->drv;
        single->initiated = 0;

        if (sem_init(&single->sem, 0, 0) < 0) {
                free(single);
                return NULL;
        }

        irq_local_save(&flags);
        ret = register_irq(IRQ_NR_FDC, NORMAL_PRIORITY, fdc_isr, single);
        irq_local_restore(flags);
        if (ret < 0) {
                sem_destroy(&single->sem);
                free(single);
                return NULL;
        }

        return single;
}

static int destroy(void *obj)
{
        struct fdc_single *single = obj;
        unsigned long flags;

        irq_local_save(&flags);
        (void)unregister_irq(IRQ_NR_FDC, fdc_isr, single);
        irq_local_restore(flags);

        sem_destroy(&single->sem);
        free(single);
        return 0;
}

static int compare(const void *_key_a, const void *_key_b)
{
        const struct fdc_key *key_a;
        const struct fdc_key *key_b;

        key_a = _key_a;
        key_b = _key_b;

        return (key_a->ctrl != key_b->ctrl) || (key_a->drv != key_b->drv);
}

int fdc_single_init(void)
{
        struct ston_ops ops = {
                .create = create,
                .destroy = destroy,
                .compare = compare,
        };

        s_ston = ston_init(&ops);
        if (!s_ston) {
                return -EFAULT;
        }

        return 0;
}

int fdc_single_fini(void)
{
        ston_fini(s_ston);
        s_ston = NULL;
        return 0;
}

struct fdc_single *fdc_single_get(enum base_address ctrl, enum drive_letter drive)
{
        struct fdc_key key;

        key.ctrl = ctrl;
        key.drv = drive;

        return ston_create(s_ston, &key);
}

int fdc_single_put(struct fdc_single *single)
{
        return ston_destroy(s_ston, single);
}

sem_t fdc_single_sem(struct fdc_single *single)
{
        return single->sem;
}

enum drive_letter fdc_single_drive(struct fdc_single *single)
{
        return single->key.drv;
}

enum base_address fdc_single_ctrl(struct fdc_single *single)
{
        return single->key.ctrl;
}

int fdc_single_is_initiated(struct fdc_single *single)
{
        return single->initiated;
}

void fdc_single_initiate(struct fdc_single *single)
{
        single->initiated = 1;
}

/* End of a file */