divasi.c

Go to the documentation of this file.

/* $Id: divasi.c,v 1.25.6.2 2005/01/31 12:22:20 armin Exp $
 *
 * Driver for Eicon DIVA Server ISDN cards.
 * User Mode IDI Interface
 *
 * Copyright 2000-2003 by Armin Schindler ([email protected])
 * Copyright 2000-2003 Cytronics & Melware ([email protected])
 *
 * This software may be used and distributed according to the terms
 * of the GNU General Public License, incorporated herein by reference.
 */

#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/poll.h>
#include <linux/proc_fs.h>
#include <linux/skbuff.h>
#include <linux/seq_file.h>
#include <asm/uaccess.h>

#include "platform.h"
#include "di_defs.h"
#include "divasync.h"
#include "um_xdi.h"
#include "um_idi.h"

static char *main_revision = "$Revision: 1.25.6.2 $";

static int major;

MODULE_DESCRIPTION("User IDI Interface for Eicon ISDN cards");
MODULE_AUTHOR("Cytronics & Melware, Eicon Networks");
MODULE_SUPPORTED_DEVICE("DIVA card driver");
MODULE_LICENSE("GPL");

typedef struct _diva_um_idi_os_context {
    wait_queue_head_t read_wait;
    wait_queue_head_t close_wait;
    struct timer_list diva_timer_id;
    int aborted;
    int adapter_nr;
} diva_um_idi_os_context_t;

static char *DRIVERNAME = "Eicon DIVA - User IDI (http://www.melware.net)";
static char *DRIVERLNAME = "diva_idi";
static char *DEVNAME = "DivasIDI";
char *DRIVERRELEASE_IDI = "2.0";

extern int idifunc_init(void);
extern void idifunc_finit(void);

/*
 *  helper functions
 */
static char *getrev(const char *revision)
{
    char *rev;
    char *p;
    if ((p = strchr(revision, ':'))) {
        rev = p + 2;
        p = strchr(rev, '$');
        *--p = 0;
    } else
        rev = "1.0";
    return rev;
}

/*
 *  LOCALS
 */
static ssize_t um_idi_read(struct file *file, char __user *buf, size_t count,
               loff_t *offset);
static ssize_t um_idi_write(struct file *file, const char __user *buf,
                size_t count, loff_t *offset);
static unsigned int um_idi_poll(struct file *file, poll_table *wait);
static int um_idi_open(struct inode *inode, struct file *file);
static int um_idi_release(struct inode *inode, struct file *file);
static int remove_entity(void *entity);
static void diva_um_timer_function(unsigned long data);

/*
 * proc entry
 */
extern struct proc_dir_entry *proc_net_eicon;
static struct proc_dir_entry *um_idi_proc_entry = NULL;

static int um_idi_proc_show(struct seq_file *m, void *v)
{
    char tmprev[32];

    seq_printf(m, "%s\n", DRIVERNAME);
    seq_printf(m, "name     : %s\n", DRIVERLNAME);
    seq_printf(m, "release  : %s\n", DRIVERRELEASE_IDI);
    strcpy(tmprev, main_revision);
    seq_printf(m, "revision : %s\n", getrev(tmprev));
    seq_printf(m, "build    : %s\n", DIVA_BUILD);
    seq_printf(m, "major    : %d\n", major);

    return 0;
}

static int um_idi_proc_open(struct inode *inode, struct file *file)
{
    return single_open(file, um_idi_proc_show, NULL);
}

static const struct file_operations um_idi_proc_fops = {
    .owner      = THIS_MODULE,
    .open       = um_idi_proc_open,
    .read       = seq_read,
    .llseek     = seq_lseek,
    .release    = single_release,
};

static int __init create_um_idi_proc(void)
{
    um_idi_proc_entry = proc_create(DRIVERLNAME, S_IRUGO, proc_net_eicon,
                    &um_idi_proc_fops);
    if (!um_idi_proc_entry)
        return (0);
    return (1);
}

static void remove_um_idi_proc(void)
{
    if (um_idi_proc_entry) {
        remove_proc_entry(DRIVERLNAME, proc_net_eicon);
        um_idi_proc_entry = NULL;
    }
}

static const struct file_operations divas_idi_fops = {
    .owner   = THIS_MODULE,
    .llseek  = no_llseek,
    .read    = um_idi_read,
    .write   = um_idi_write,
    .poll    = um_idi_poll,
    .open    = um_idi_open,
    .release = um_idi_release
};

static void divas_idi_unregister_chrdev(void)
{
    unregister_chrdev(major, DEVNAME);
}

static int __init divas_idi_register_chrdev(void)
{
    if ((major = register_chrdev(0, DEVNAME, &divas_idi_fops)) < 0)
    {
        printk(KERN_ERR "%s: failed to create /dev entry.\n",
               DRIVERLNAME);
        return (0);
    }

    return (1);
}

/*
** Driver Load
*/
static int __init divasi_init(void)
{
    char tmprev[50];
    int ret = 0;

    printk(KERN_INFO "%s\n", DRIVERNAME);
    printk(KERN_INFO "%s: Rel:%s  Rev:", DRIVERLNAME, DRIVERRELEASE_IDI);
    strcpy(tmprev, main_revision);
    printk("%s  Build: %s\n", getrev(tmprev), DIVA_BUILD);

    if (!divas_idi_register_chrdev()) {
        ret = -EIO;
        goto out;
    }

    if (!create_um_idi_proc()) {
        divas_idi_unregister_chrdev();
        printk(KERN_ERR "%s: failed to create proc entry.\n",
               DRIVERLNAME);
        ret = -EIO;
        goto out;
    }

    if (!(idifunc_init())) {
        remove_um_idi_proc();
        divas_idi_unregister_chrdev();
        printk(KERN_ERR "%s: failed to connect to DIDD.\n",
               DRIVERLNAME);
        ret = -EIO;
        goto out;
    }
    printk(KERN_INFO "%s: started with major %d\n", DRIVERLNAME, major);

out:
    return (ret);
}


/*
** Driver Unload
*/
static void __exit divasi_exit(void)
{
    idifunc_finit();
    remove_um_idi_proc();
    divas_idi_unregister_chrdev();

    printk(KERN_INFO "%s: module unloaded.\n", DRIVERLNAME);
}

module_init(divasi_init);
module_exit(divasi_exit);


/*
 *  FILE OPERATIONS
 */

static int
divas_um_idi_copy_to_user(void *os_handle, void *dst, const void *src,
              int length)
{
    memcpy(dst, src, length);
    return (length);
}

static ssize_t
um_idi_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
{
    diva_um_idi_os_context_t *p_os;
    int ret = -EINVAL;
    void *data;

    if (!file->private_data) {
        return (-ENODEV);
    }

    if (!
        (p_os =
         (diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
                                    private_data)))
    {
        return (-ENODEV);
    }
    if (p_os->aborted) {
        return (-ENODEV);
    }

    if (!(data = diva_os_malloc(0, count))) {
        return (-ENOMEM);
    }

    ret = diva_um_idi_read(file->private_data,
                   file, data, count,
                   divas_um_idi_copy_to_user);
    switch (ret) {
    case 0:     /* no message available */
        ret = (-EAGAIN);
        break;
    case (-1):      /* adapter was removed */
        ret = (-ENODEV);
        break;
    case (-2):      /* message_length > length of user buffer */
        ret = (-EFAULT);
        break;
    }

    if (ret > 0) {
        if (copy_to_user(buf, data, ret)) {
            ret = (-EFAULT);
        }
    }

    diva_os_free(0, data);
    DBG_TRC(("read: ret %d", ret));
    return (ret);
}


static int
divas_um_idi_copy_from_user(void *os_handle, void *dst, const void *src,
                int length)
{
    memcpy(dst, src, length);
    return (length);
}

static int um_idi_open_adapter(struct file *file, int adapter_nr)
{
    diva_um_idi_os_context_t *p_os;
    void *e =
        divas_um_idi_create_entity((dword) adapter_nr, (void *) file);

    if (!(file->private_data = e)) {
        return (0);
    }
    p_os = (diva_um_idi_os_context_t *) diva_um_id_get_os_context(e);
    init_waitqueue_head(&p_os->read_wait);
    init_waitqueue_head(&p_os->close_wait);
    init_timer(&p_os->diva_timer_id);
    p_os->diva_timer_id.function = (void *) diva_um_timer_function;
    p_os->diva_timer_id.data = (unsigned long) p_os;
    p_os->aborted = 0;
    p_os->adapter_nr = adapter_nr;
    return (1);
}

static ssize_t
um_idi_write(struct file *file, const char __user *buf, size_t count,
         loff_t *offset)
{
    diva_um_idi_os_context_t *p_os;
    int ret = -EINVAL;
    void *data;
    int adapter_nr = 0;

    if (!file->private_data) {
        /* the first write() selects the adapter_nr */
        if (count == sizeof(int)) {
            if (copy_from_user
                ((void *) &adapter_nr, buf,
                 count)) return (-EFAULT);
            if (!(um_idi_open_adapter(file, adapter_nr)))
                return (-ENODEV);
            return (count);
        } else
            return (-ENODEV);
    }

    if (!(p_os =
          (diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
                                     private_data)))
    {
        return (-ENODEV);
    }
    if (p_os->aborted) {
        return (-ENODEV);
    }

    if (!(data = diva_os_malloc(0, count))) {
        return (-ENOMEM);
    }

    if (copy_from_user(data, buf, count)) {
        ret = -EFAULT;
    } else {
        ret = diva_um_idi_write(file->private_data,
                    file, data, count,
                    divas_um_idi_copy_from_user);
        switch (ret) {
        case 0: /* no space available */
            ret = (-EAGAIN);
            break;
        case (-1):  /* adapter was removed */
            ret = (-ENODEV);
            break;
        case (-2):  /* length of user buffer > max message_length */
            ret = (-EFAULT);
            break;
        }
    }
    diva_os_free(0, data);
    DBG_TRC(("write: ret %d", ret));
    return (ret);
}

static unsigned int um_idi_poll(struct file *file, poll_table *wait)
{
    diva_um_idi_os_context_t *p_os;

    if (!file->private_data) {
        return (POLLERR);
    }

    if ((!(p_os =
           (diva_um_idi_os_context_t *)
           diva_um_id_get_os_context(file->private_data)))
        || p_os->aborted) {
        return (POLLERR);
    }

    poll_wait(file, &p_os->read_wait, wait);

    if (p_os->aborted) {
        return (POLLERR);
    }

    switch (diva_user_mode_idi_ind_ready(file->private_data, file)) {
    case (-1):
        return (POLLERR);

    case 0:
        return (0);
    }

    return (POLLIN | POLLRDNORM);
}

static int um_idi_open(struct inode *inode, struct file *file)
{
    return (0);
}


static int um_idi_release(struct inode *inode, struct file *file)
{
    diva_um_idi_os_context_t *p_os;
    unsigned int adapter_nr;
    int ret = 0;

    if (!(file->private_data)) {
        ret = -ENODEV;
        goto out;
    }

    if (!(p_os =
          (diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->private_data))) {
        ret = -ENODEV;
        goto out;
    }

    adapter_nr = p_os->adapter_nr;

    if ((ret = remove_entity(file->private_data))) {
        goto out;
    }

    if (divas_um_idi_delete_entity
        ((int) adapter_nr, file->private_data)) {
        ret = -ENODEV;
        goto out;
    }

out:
    return (ret);
}

int diva_os_get_context_size(void)
{
    return (sizeof(diva_um_idi_os_context_t));
}

void diva_os_wakeup_read(void *os_context)
{
    diva_um_idi_os_context_t *p_os =
        (diva_um_idi_os_context_t *) os_context;
    wake_up_interruptible(&p_os->read_wait);
}

void diva_os_wakeup_close(void *os_context)
{
    diva_um_idi_os_context_t *p_os =
        (diva_um_idi_os_context_t *) os_context;
    wake_up_interruptible(&p_os->close_wait);
}

static
void diva_um_timer_function(unsigned long data)
{
    diva_um_idi_os_context_t *p_os = (diva_um_idi_os_context_t *) data;

    p_os->aborted = 1;
    wake_up_interruptible(&p_os->read_wait);
    wake_up_interruptible(&p_os->close_wait);
    DBG_ERR(("entity removal watchdog"))
        }

/*
**  If application exits without entity removal this function will remove
**  entity and block until removal is complete
*/
static int remove_entity(void *entity)
{
    struct task_struct *curtask = current;
    diva_um_idi_os_context_t *p_os;

    diva_um_idi_stop_wdog(entity);

    if (!entity) {
        DBG_FTL(("Zero entity on remove"))
            return (0);
    }

    if (!(p_os =
          (diva_um_idi_os_context_t *)
          diva_um_id_get_os_context(entity))) {
        DBG_FTL(("Zero entity os context on remove"))
            return (0);
    }

    if (!divas_um_idi_entity_assigned(entity) || p_os->aborted) {
        /*
          Entity is not assigned, also can be removed
        */
        return (0);
    }

    DBG_TRC(("E(%08x) check remove", entity))

        /*
          If adapter not answers on remove request inside of
          10 Sec, then adapter is dead
        */
        diva_um_idi_start_wdog(entity);

    {
        DECLARE_WAITQUEUE(wait, curtask);

        add_wait_queue(&p_os->close_wait, &wait);
        for (;;) {
            set_current_state(TASK_INTERRUPTIBLE);
            if (!divas_um_idi_entity_start_remove(entity)
                || p_os->aborted) {
                break;
            }
            schedule();
        }
        set_current_state(TASK_RUNNING);
        remove_wait_queue(&p_os->close_wait, &wait);
    }

    DBG_TRC(("E(%08x) start remove", entity))
    {
        DECLARE_WAITQUEUE(wait, curtask);

        add_wait_queue(&p_os->close_wait, &wait);
        for (;;) {
            set_current_state(TASK_INTERRUPTIBLE);
            if (!divas_um_idi_entity_assigned(entity)
                || p_os->aborted) {
                break;
            }
            schedule();
        }
        set_current_state(TASK_RUNNING);
        remove_wait_queue(&p_os->close_wait, &wait);
    }

    DBG_TRC(("E(%08x) remove complete, aborted:%d", entity,
         p_os->aborted))

        diva_um_idi_stop_wdog(entity);

    p_os->aborted = 0;

    return (0);
}

/*
 * timer watchdog
 */
void diva_um_idi_start_wdog(void *entity)
{
    diva_um_idi_os_context_t *p_os;

    if (entity &&
        ((p_os =
          (diva_um_idi_os_context_t *)
          diva_um_id_get_os_context(entity)))) {
        mod_timer(&p_os->diva_timer_id, jiffies + 10 * HZ);
    }
}

void diva_um_idi_stop_wdog(void *entity)
{
    diva_um_idi_os_context_t *p_os;

    if (entity &&
        ((p_os =
          (diva_um_idi_os_context_t *)
          diva_um_id_get_os_context(entity)))) {
        del_timer(&p_os->diva_timer_id);
    }
}