[deliverable/linux.git] / 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/smp_lock.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_read(char *page, char **start, off_t off, int count, int *eof,
		 void *data)
{
	int len = 0;
	char tmprev[32];

	len += sprintf(page + len, "%s\n", DRIVERNAME);
	len += sprintf(page + len, "name     : %s\n", DRIVERLNAME);
	len += sprintf(page + len, "release  : %s\n", DRIVERRELEASE_IDI);
	strcpy(tmprev, main_revision);
	len += sprintf(page + len, "revision : %s\n", getrev(tmprev));
	len += sprintf(page + len, "build    : %s\n", DIVA_BUILD);
	len += sprintf(page + len, "major    : %d\n", major);

	if (off + count >= len)
		*eof = 1;
	if (len < off)
		return 0;
	*start = page + off;
	return ((count < len - off) ? count : len - off);
}

static int DIVA_INIT_FUNCTION create_um_idi_proc(void)
{
	um_idi_proc_entry = create_proc_entry(DRIVERLNAME,
					      S_IFREG | S_IRUGO | S_IWUSR,
					      proc_net_eicon);
	if (!um_idi_proc_entry)
		return (0);

	um_idi_proc_entry->read_proc = um_idi_proc_read;

	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 DIVA_INIT_FUNCTION 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 DIVA_INIT_FUNCTION 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 DIVA_EXIT_FUNCTION 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)
{
	cycle_kernel_lock();
	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);
	}
}
Commit	Line	Data
1da177e4 LT	1	/* $Id: divasi.c,v 1.25.6.2 2005/01/31 12:22:20 armin Exp $
	2	*
	3	* Driver for Eicon DIVA Server ISDN cards.
	4	* User Mode IDI Interface
	5	*
	6	* Copyright 2000-2003 by Armin Schindler (mac@melware.de)
	7	* Copyright 2000-2003 Cytronics & Melware (info@melware.de)
	8	*
	9	* This software may be used and distributed according to the terms
	10	* of the GNU General Public License, incorporated herein by reference.
	11	*/
	12
1da177e4 LT	13	#include <linux/module.h>
	14	#include <linux/init.h>
	15	#include <linux/kernel.h>
	16	#include <linux/sched.h>
1da177e4 LT	17	#include <linux/poll.h>
	18	#include <linux/proc_fs.h>
	19	#include <linux/skbuff.h>
f2b9857e	20	#include <linux/smp_lock.h>
1da177e4 LT	21	#include <asm/uaccess.h>
	22
	23	#include "platform.h"
	24	#include "di_defs.h"
	25	#include "divasync.h"
	26	#include "um_xdi.h"
	27	#include "um_idi.h"
	28
	29	static char *main_revision = "$Revision: 1.25.6.2 $";
	30
	31	static int major;
	32
	33	MODULE_DESCRIPTION("User IDI Interface for Eicon ISDN cards");
	34	MODULE_AUTHOR("Cytronics & Melware, Eicon Networks");
	35	MODULE_SUPPORTED_DEVICE("DIVA card driver");
	36	MODULE_LICENSE("GPL");
	37
	38	typedef struct _diva_um_idi_os_context {
	39	wait_queue_head_t read_wait;
	40	wait_queue_head_t close_wait;
	41	struct timer_list diva_timer_id;
	42	int aborted;
	43	int adapter_nr;
	44	} diva_um_idi_os_context_t;
	45
	46	static char *DRIVERNAME = "Eicon DIVA - User IDI (http://www.melware.net)";
	47	static char *DRIVERLNAME = "diva_idi";
	48	static char *DEVNAME = "DivasIDI";
	49	char *DRIVERRELEASE_IDI = "2.0";
	50
	51	extern int idifunc_init(void);
	52	extern void idifunc_finit(void);
	53
	54	/*
	55	* helper functions
	56	*/
	57	static char getrev(const char revision)
	58	{
	59	char *rev;
	60	char *p;
	61	if ((p = strchr(revision, ':'))) {
	62	rev = p + 2;
	63	p = strchr(rev, '$');
	64	*--p = 0;
	65	} else
	66	rev = "1.0";
	67	return rev;
	68	}
	69
	70	/*
	71	* LOCALS
	72	*/
	73	static ssize_t um_idi_read(struct file file, char __user buf, size_t count,
	74	loff_t * offset);
	75	static ssize_t um_idi_write(struct file file, const char __user buf,
	76	size_t count, loff_t * offset);
	77	static unsigned int um_idi_poll(struct file file, poll_table wait);
	78	static int um_idi_open(struct inode inode, struct file file);
	79	static int um_idi_release(struct inode inode, struct file file);
	80	static int remove_entity(void *entity);
	81	static void diva_um_timer_function(unsigned long data);
	82
	83	/*
	84	* proc entry
85	*/
86	extern struct proc_dir_entry *proc_net_eicon;
87	static struct proc_dir_entry *um_idi_proc_entry = NULL;
88
89	static int
90	um_idi_proc_read(char page, char start, off_t off, int count, int eof,
91	void *data)
92	{
93	int len = 0;
94	char tmprev[32];
95
96	len += sprintf(page + len, "%s\n", DRIVERNAME);
97	len += sprintf(page + len, "name : %s\n", DRIVERLNAME);
98	len += sprintf(page + len, "release : %s\n", DRIVERRELEASE_IDI);
99	strcpy(tmprev, main_revision);
100	len += sprintf(page + len, "revision : %s\n", getrev(tmprev));
101	len += sprintf(page + len, "build : %s\n", DIVA_BUILD);
102	len += sprintf(page + len, "major : %d\n", major);
103
104	if (off + count >= len)
105	*eof = 1;
106	if (len < off)
107	return 0;
108	*start = page + off;
109	return ((count < len - off) ? count : len - off);
110	}
111
112	static int DIVA_INIT_FUNCTION create_um_idi_proc(void)
113	{
114	um_idi_proc_entry = create_proc_entry(DRIVERLNAME,
115	S_IFREG \| S_IRUGO \| S_IWUSR,
116	proc_net_eicon);
117	if (!um_idi_proc_entry)
118	return (0);
119
120	um_idi_proc_entry->read_proc = um_idi_proc_read;
1da177e4 LT	121
	122	return (1);
	123	}
	124
	125	static void remove_um_idi_proc(void)
	126	{
	127	if (um_idi_proc_entry) {
	128	remove_proc_entry(DRIVERLNAME, proc_net_eicon);
	129	um_idi_proc_entry = NULL;
	130	}
	131	}
	132
2b8693c0	133	static const struct file_operations divas_idi_fops = {
1da177e4 LT	134	.owner = THIS_MODULE,
	135	.llseek = no_llseek,
	136	.read = um_idi_read,
	137	.write = um_idi_write,
	138	.poll = um_idi_poll,
	139	.open = um_idi_open,
	140	.release = um_idi_release
	141	};
	142
	143	static void divas_idi_unregister_chrdev(void)
	144	{
1da177e4 LT	145	unregister_chrdev(major, DEVNAME);
	146	}
	147
	148	static int DIVA_INIT_FUNCTION divas_idi_register_chrdev(void)
	149	{
	150	if ((major = register_chrdev(0, DEVNAME, &divas_idi_fops)) < 0)
	151	{
	152	printk(KERN_ERR "%s: failed to create /dev entry.\n",
	153	DRIVERLNAME);
	154	return (0);
	155	}
1da177e4 LT	156
	157	return (1);
	158	}
	159
	160	/*
	161	** Driver Load
	162	*/
	163	static int DIVA_INIT_FUNCTION divasi_init(void)
	164	{
	165	char tmprev[50];
	166	int ret = 0;
	167
	168	printk(KERN_INFO "%s\n", DRIVERNAME);
	169	printk(KERN_INFO "%s: Rel:%s Rev:", DRIVERLNAME, DRIVERRELEASE_IDI);
	170	strcpy(tmprev, main_revision);
	171	printk("%s Build: %s\n", getrev(tmprev), DIVA_BUILD);
	172
	173	if (!divas_idi_register_chrdev()) {
	174	ret = -EIO;
	175	goto out;
	176	}
	177
	178	if (!create_um_idi_proc()) {
	179	divas_idi_unregister_chrdev();
	180	printk(KERN_ERR "%s: failed to create proc entry.\n",
	181	DRIVERLNAME);
	182	ret = -EIO;
	183	goto out;
	184	}
	185
	186	if (!(idifunc_init())) {
	187	remove_um_idi_proc();
	188	divas_idi_unregister_chrdev();
	189	printk(KERN_ERR "%s: failed to connect to DIDD.\n",
	190	DRIVERLNAME);
	191	ret = -EIO;
	192	goto out;
	193	}
	194	printk(KERN_INFO "%s: started with major %d\n", DRIVERLNAME, major);
	195
	196	out:
	197	return (ret);
	198	}
	199
	200
	201	/*
	202	** Driver Unload
	203	*/
	204	static void DIVA_EXIT_FUNCTION divasi_exit(void)
	205	{
	206	idifunc_finit();
	207	remove_um_idi_proc();
	208	divas_idi_unregister_chrdev();
	209
	210	printk(KERN_INFO "%s: module unloaded.\n", DRIVERLNAME);
	211	}
	212
	213	module_init(divasi_init);
	214	module_exit(divasi_exit);
	215
	216
	217	/*
	218	* FILE OPERATIONS
	219	*/
220
221	static int
222	divas_um_idi_copy_to_user(void os_handle, void dst, const void *src,
223	int length)
224	{
225	memcpy(dst, src, length);
226	return (length);
227	}
228
229	static ssize_t
230	um_idi_read(struct file file, char __user buf, size_t count, loff_t * offset)
231	{
232	diva_um_idi_os_context_t *p_os;
233	int ret = -EINVAL;
234	void *data;
235
236	if (!file->private_data) {
237	return (-ENODEV);
238	}
239
240	if (!
241	(p_os =
242	(diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
243	private_data)))
244	{
245	return (-ENODEV);
246	}
247	if (p_os->aborted) {
248	return (-ENODEV);
249	}
250
251	if (!(data = diva_os_malloc(0, count))) {
252	return (-ENOMEM);
253	}
254
255	ret = diva_um_idi_read(file->private_data,
256	file, data, count,
257	divas_um_idi_copy_to_user);
258	switch (ret) {
259	case 0: /* no message available */
260	ret = (-EAGAIN);
261	break;
262	case (-1): /* adapter was removed */
263	ret = (-ENODEV);
264	break;
265	case (-2): /* message_length > length of user buffer */
266	ret = (-EFAULT);
267	break;
268	}
269
270	if (ret > 0) {
271	if (copy_to_user(buf, data, ret)) {
272	ret = (-EFAULT);
273	}
274	}
275
276	diva_os_free(0, data);
277	DBG_TRC(("read: ret %d", ret));
278	return (ret);
279	}
280
281
282	static int
283	divas_um_idi_copy_from_user(void os_handle, void dst, const void *src,
284	int length)
285	{
286	memcpy(dst, src, length);
287	return (length);
288	}
289
290	static int um_idi_open_adapter(struct file *file, int adapter_nr)
291	{
292	diva_um_idi_os_context_t *p_os;
293	void *e =
294	divas_um_idi_create_entity((dword) adapter_nr, (void *) file);
295
296	if (!(file->private_data = e)) {
297	return (0);
298	}
299	p_os = (diva_um_idi_os_context_t *) diva_um_id_get_os_context(e);
300	init_waitqueue_head(&p_os->read_wait);
301	init_waitqueue_head(&p_os->close_wait);
302	init_timer(&p_os->diva_timer_id);
303	p_os->diva_timer_id.function = (void *) diva_um_timer_function;
304	p_os->diva_timer_id.data = (unsigned long) p_os;
305	p_os->aborted = 0;
306	p_os->adapter_nr = adapter_nr;
307	return (1);
308	}
309
310	static ssize_t
311	um_idi_write(struct file file, const char __user buf, size_t count,
312	loff_t * offset)
313	{
314	diva_um_idi_os_context_t *p_os;
315	int ret = -EINVAL;
316	void *data;
317	int adapter_nr = 0;
318
319	if (!file->private_data) {
320	/* the first write() selects the adapter_nr */
321	if (count == sizeof(int)) {
322	if (copy_from_user
323	((void *) &adapter_nr, buf,
324	count)) return (-EFAULT);
325	if (!(um_idi_open_adapter(file, adapter_nr)))
326	return (-ENODEV);
327	return (count);
328	} else
329	return (-ENODEV);
330	}
331
332	if (!(p_os =
333	(diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
334	private_data)))
335	{
336	return (-ENODEV);
337	}
338	if (p_os->aborted) {
339	return (-ENODEV);
340	}
341
342	if (!(data = diva_os_malloc(0, count))) {
343	return (-ENOMEM);
344	}
345
346	if (copy_from_user(data, buf, count)) {
347	ret = -EFAULT;
348	} else {
349	ret = diva_um_idi_write(file->private_data,
350	file, data, count,
351	divas_um_idi_copy_from_user);
352	switch (ret) {
353	case 0: /* no space available */
354	ret = (-EAGAIN);
355	break;
356	case (-1): /* adapter was removed */
357	ret = (-ENODEV);
358	break;
359	case (-2): /* length of user buffer > max message_length */
360	ret = (-EFAULT);
361	break;
362	}
363	}
364	diva_os_free(0, data);
365	DBG_TRC(("write: ret %d", ret));
366	return (ret);
367	}
368
369	static unsigned int um_idi_poll(struct file file, poll_table wait)
370	{
371	diva_um_idi_os_context_t *p_os;
372
373	if (!file->private_data) {
374	return (POLLERR);
375	}
376
377	if ((!(p_os =
378	(diva_um_idi_os_context_t *)
379	diva_um_id_get_os_context(file->private_data)))
380	\|\| p_os->aborted) {
381	return (POLLERR);
382	}
383
384	poll_wait(file, &p_os->read_wait, wait);
385
386	if (p_os->aborted) {
387	return (POLLERR);
388	}
389
390	switch (diva_user_mode_idi_ind_ready(file->private_data, file)) {
391	case (-1):
392	return (POLLERR);
393
394	case 0:
395	return (0);
396	}
397
398	return (POLLIN \| POLLRDNORM);
399	}
400
401	static int um_idi_open(struct inode inode, struct file file)
402	{
f2b9857e	403	cycle_kernel_lock();
1da177e4 LT	404	return (0);
	405	}
	406
	407
	408	static int um_idi_release(struct inode inode, struct file file)
	409	{
	410	diva_um_idi_os_context_t *p_os;
	411	unsigned int adapter_nr;
	412	int ret = 0;
	413
	414	if (!(file->private_data)) {
	415	ret = -ENODEV;
	416	goto out;
	417	}
	418
	419	if (!(p_os =
	420	(diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->private_data))) {
	421	ret = -ENODEV;
	422	goto out;
	423	}
	424
	425	adapter_nr = p_os->adapter_nr;
	426
	427	if ((ret = remove_entity(file->private_data))) {
	428	goto out;
	429	}
	430
	431	if (divas_um_idi_delete_entity
	432	((int) adapter_nr, file->private_data)) {
	433	ret = -ENODEV;
	434	goto out;
	435	}
	436
	437	out:
	438	return (ret);
	439	}
	440
	441	int diva_os_get_context_size(void)
	442	{
	443	return (sizeof(diva_um_idi_os_context_t));
	444	}
	445
	446	void diva_os_wakeup_read(void *os_context)
	447	{
	448	diva_um_idi_os_context_t *p_os =
	449	(diva_um_idi_os_context_t *) os_context;
	450	wake_up_interruptible(&p_os->read_wait);
	451	}
	452
	453	void diva_os_wakeup_close(void *os_context)
	454	{
	455	diva_um_idi_os_context_t *p_os =
	456	(diva_um_idi_os_context_t *) os_context;
	457	wake_up_interruptible(&p_os->close_wait);
	458	}
	459
	460	static
	461	void diva_um_timer_function(unsigned long data)
	462	{
	463	diva_um_idi_os_context_t p_os = (diva_um_idi_os_context_t ) data;
	464
	465	p_os->aborted = 1;
	466	wake_up_interruptible(&p_os->read_wait);
	467	wake_up_interruptible(&p_os->close_wait);
468	DBG_ERR(("entity removal watchdog"))
469	}
470
471	/*
472	** If application exits without entity removal this function will remove
473	** entity and block until removal is complete
474	*/
475	static int remove_entity(void *entity)
476	{
477	struct task_struct *curtask = current;
478	diva_um_idi_os_context_t *p_os;
479
480	diva_um_idi_stop_wdog(entity);
481
482	if (!entity) {
483	DBG_FTL(("Zero entity on remove"))
484	return (0);
485	}
486
487	if (!(p_os =
488	(diva_um_idi_os_context_t *)
489	diva_um_id_get_os_context(entity))) {
490	DBG_FTL(("Zero entity os context on remove"))
491	return (0);
492	}
493
494	if (!divas_um_idi_entity_assigned(entity) \|\| p_os->aborted) {
495	/*
496	Entity is not assigned, also can be removed
497	*/
498	return (0);
499	}
500
501	DBG_TRC(("E(%08x) check remove", entity))
502
503	/*
504	If adapter not answers on remove request inside of
505	10 Sec, then adapter is dead
506	*/
507	diva_um_idi_start_wdog(entity);
508
509	{
510	DECLARE_WAITQUEUE(wait, curtask);
511
512	add_wait_queue(&p_os->close_wait, &wait);
513	for (;;) {
514	set_current_state(TASK_INTERRUPTIBLE);
515	if (!divas_um_idi_entity_start_remove(entity)
516	\|\| p_os->aborted) {
517	break;
518	}
519	schedule();
520	}
521	set_current_state(TASK_RUNNING);
522	remove_wait_queue(&p_os->close_wait, &wait);
523	}
524
525	DBG_TRC(("E(%08x) start remove", entity))
526	{
527	DECLARE_WAITQUEUE(wait, curtask);
528
529	add_wait_queue(&p_os->close_wait, &wait);
530	for (;;) {
531	set_current_state(TASK_INTERRUPTIBLE);
532	if (!divas_um_idi_entity_assigned(entity)
533	\|\| p_os->aborted) {
534	break;
535	}
536	schedule();
537	}
538	set_current_state(TASK_RUNNING);
539	remove_wait_queue(&p_os->close_wait, &wait);
540	}
541
542	DBG_TRC(("E(%08x) remove complete, aborted:%d", entity,
543	p_os->aborted))
544
545	diva_um_idi_stop_wdog(entity);
546
547	p_os->aborted = 0;
548
549	return (0);
550	}
551
552	/*
553	* timer watchdog
554	*/
555	void diva_um_idi_start_wdog(void *entity)
556	{
557	diva_um_idi_os_context_t *p_os;
558
559	if (entity &&
560	((p_os =
561	(diva_um_idi_os_context_t *)
562	diva_um_id_get_os_context(entity)))) {
563	mod_timer(&p_os->diva_timer_id, jiffies + 10 * HZ);
564	}
565	}
566
567	void diva_um_idi_stop_wdog(void *entity)
568	{
569	diva_um_idi_os_context_t *p_os;
570
571	if (entity &&
572	((p_os =
573	(diva_um_idi_os_context_t *)
574	diva_um_id_get_os_context(entity)))) {
575	del_timer(&p_os->diva_timer_id);
576	}
577	}