Release 4.14 drivers/isdn/hardware/eicon/divasi.c

/* $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 (mac@melware.de)
 * Copyright 2000-2003 Cytronics & Melware (info@melware.de)
 *
 * 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 <linux/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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
64
100.00%
1
100.00%
Total
64
100.00%
1
100.00%

/*
 *  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;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
70
79.55%
2
66.67%
Alexey Dobriyan
18
20.45%
1
33.33%
Total
88
100.00%
3
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Alexey Dobriyan
23
88.46%
1
50.00%
Armin Schindler
3
11.54%
1
50.00%
Total
26
100.00%
2
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
33
86.84%
2
50.00%
Alexey Dobriyan
4
10.53%
1
25.00%
H Hartley Sweeten
1
2.63%
1
25.00%
Total
38
100.00%
4
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
25
100.00%
2
100.00%
Total
25
100.00%
2
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
15
100.00%
2
100.00%
Total
15
100.00%
2
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
46
97.87%
2
66.67%
H Hartley Sweeten
1
2.13%
1
33.33%
Total
47
100.00%
3
100.00%

/*
** 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);
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
148
99.33%
2
66.67%
H Hartley Sweeten
1
0.67%
1
33.33%
Total
149
100.00%
3
100.00%

/*
** 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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
25
96.15%
1
50.00%
H Hartley Sweeten
1
3.85%
1
50.00%
Total
26
100.00%
2
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
36
100.00%
1
100.00%
Total
36
100.00%
1
100.00%


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);
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
227
99.56%
1
50.00%
Al Viro
1
0.44%
1
50.00%
Total
228
100.00%
2
100.00%


static int

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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
36
100.00%
1
100.00%
Total
36
100.00%
1
100.00%



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);
	setup_timer(&p_os->diva_timer_id, (void *)diva_um_timer_function,
		    (unsigned long)p_os);
	p_os->aborted = 0;
	p_os->adapter_nr = adapter_nr;
	return (1);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
114
96.61%
2
66.67%
Geliang Tang
4
3.39%
1
33.33%
Total
118
100.00%
3
100.00%


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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
284
99.65%
1
50.00%
Al Viro
1
0.35%
1
50.00%
Total
285
100.00%
2
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
129
100.00%
1
100.00%
Total
129
100.00%
1
100.00%



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


Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
21
100.00%
1
100.00%
Total
21
100.00%
1
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
131
100.00%
2
100.00%
Total
131
100.00%
2
100.00%



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

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
14
93.33%
1
50.00%
Kai Germaschewski
1
6.67%
1
50.00%
Total
15
100.00%
2
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
26
96.30%
1
50.00%
Kai Germaschewski
1
3.70%
1
50.00%
Total
27
100.00%
2
100.00%



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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
26
96.30%
1
50.00%
Kai Germaschewski
1
3.70%
1
50.00%
Total
27
100.00%
2
100.00%


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"))
		}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
48
100.00%
1
100.00%
Total
48
100.00%
1
100.00%

/*
**  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);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
262
98.87%
1
33.33%
Joe Perches
2
0.75%
1
33.33%
Kai Germaschewski
1
0.38%
1
33.33%
Total
265
100.00%
3
100.00%

/*
 * 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);
	}
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
48
100.00%
1
100.00%
Total
48
100.00%
1
100.00%



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);
	}
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
42
100.00%
1
100.00%
Total
42
100.00%
1
100.00%

Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Armin Schindler
2170
94.84%
3
25.00%
Alexey Dobriyan
81
3.54%
1
8.33%
Kai Germaschewski
20
0.87%
2
16.67%
Al Viro
4
0.17%
1
8.33%
H Hartley Sweeten
4
0.17%
1
8.33%
Geliang Tang
4
0.17%
1
8.33%
Joe Perches
3
0.13%
1
8.33%
Linus Torvalds
1
0.04%
1
8.33%
Arjan van de Ven
1
0.04%
1
8.33%
Total
2288
100.00%
12
100.00%
Directory: drivers/isdn/hardware/eicon

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.