URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [isdn/] [hardware/] [eicon/] [divasi.c] - Blame information for rev 62

Details | Compare with Previous | View Log


/* $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 <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;
        um_idi_proc_entry->owner = THIS_MODULE;
 
        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)
{
        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);
        }
}

Browse

Tools

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [isdn/] [hardware/] [eicon/] [divasi.c] - Blame information for rev 62

Line No.	Rev	Author	Line
1	62	marcus.erl	`/* $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
13			`#include <linux/module.h>`
14			`#include <linux/init.h>`
15			`#include <linux/kernel.h>`
16			`#include <linux/sched.h>`
17			`#include <linux/poll.h>`
18			`#include <linux/proc_fs.h>`
19			`#include <linux/skbuff.h>`
20			`#include <asm/uaccess.h>`
21
22			`#include "platform.h"`
23			`#include "di_defs.h"`
24			`#include "divasync.h"`
25			`#include "um_xdi.h"`
26			`#include "um_idi.h"`
27
28			`static char *main_revision = "$Revision: 1.25.6.2 $";`
29
30			`static int major;`
31
32			`MODULE_DESCRIPTION("User IDI Interface for Eicon ISDN cards");`
33			`MODULE_AUTHOR("Cytronics & Melware, Eicon Networks");`
34			`MODULE_SUPPORTED_DEVICE("DIVA card driver");`
35			`MODULE_LICENSE("GPL");`
36
37			`typedef struct _diva_um_idi_os_context {`
38			`wait_queue_head_t read_wait;`
39			`wait_queue_head_t close_wait;`
40			`struct timer_list diva_timer_id;`
41			`int aborted;`
42			`int adapter_nr;`
43			`} diva_um_idi_os_context_t;`
44
45			`static char *DRIVERNAME = "Eicon DIVA - User IDI (http://www.melware.net)";`
46			`static char *DRIVERLNAME = "diva_idi";`
47			`static char *DEVNAME = "DivasIDI";`
48			`char *DRIVERRELEASE_IDI = "2.0";`
49
50			`extern int idifunc_init(void);`
51			`extern void idifunc_finit(void);`
52
53			`/*`
54			`* helper functions`
55			`*/`
56			`static char getrev(const char revision)`
57			`{`
58			`char *rev;`
59			`char *p;`
60			`if ((p = strchr(revision, ':'))) {`
61			`rev = p + 2;`
62			`p = strchr(rev, '$');`
63			`*--p = 0;`
64			`} else`
65			`rev = "1.0";`
66			`return rev;`
67			`}`
68
69			`/*`
70			`* LOCALS`
71			`*/`
72			`static ssize_t um_idi_read(struct file file, char __user buf, size_t count,`
73			`loff_t * offset);`
74			`static ssize_t um_idi_write(struct file file, const char __user buf,`
75			`size_t count, loff_t * offset);`
76			`static unsigned int um_idi_poll(struct file file, poll_table wait);`
77			`static int um_idi_open(struct inode inode, struct file file);`
78			`static int um_idi_release(struct inode inode, struct file file);`
79			`static int remove_entity(void *entity);`
80			`static void diva_um_timer_function(unsigned long data);`
81
82			`/*`
83			`* proc entry`
84			`*/`
85			`extern struct proc_dir_entry *proc_net_eicon;`
86			`static struct proc_dir_entry *um_idi_proc_entry = NULL;`
87
88			`static int`
89			`um_idi_proc_read(char page, char start, off_t off, int count, int eof,`
90			`void *data)`
91			`{`
92			`int len = 0;`
93			`char tmprev[32];`
94
95			`len += sprintf(page + len, "%s\n", DRIVERNAME);`
96			`len += sprintf(page + len, "name : %s\n", DRIVERLNAME);`
97			`len += sprintf(page + len, "release : %s\n", DRIVERRELEASE_IDI);`
98			`strcpy(tmprev, main_revision);`
99			`len += sprintf(page + len, "revision : %s\n", getrev(tmprev));`
100			`len += sprintf(page + len, "build : %s\n", DIVA_BUILD);`
101			`len += sprintf(page + len, "major : %d\n", major);`
102
103			`if (off + count >= len)`
104			`*eof = 1;`
105			`if (len < off)`
106			`return 0;`
107			`*start = page + off;`
108			`return ((count < len - off) ? count : len - off);`
109			`}`
110
111			`static int DIVA_INIT_FUNCTION create_um_idi_proc(void)`
112			`{`
113			`um_idi_proc_entry = create_proc_entry(DRIVERLNAME,`
114			`S_IFREG \| S_IRUGO \| S_IWUSR,`
115			`proc_net_eicon);`
116			`if (!um_idi_proc_entry)`
117			`return (0);`
118
119			`um_idi_proc_entry->read_proc = um_idi_proc_read;`
120			`um_idi_proc_entry->owner = THIS_MODULE;`
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
133			`static const struct file_operations divas_idi_fops = {`
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			`{`
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			`}`
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			`{`
403			`return (0);`
404			`}`
405
406
407			`static int um_idi_release(struct inode inode, struct file file)`
408			`{`
409			`diva_um_idi_os_context_t *p_os;`
410			`unsigned int adapter_nr;`
411			`int ret = 0;`
412
413			`if (!(file->private_data)) {`
414			`ret = -ENODEV;`
415			`goto out;`
416			`}`
417
418			`if (!(p_os =`
419			`(diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->private_data))) {`
420			`ret = -ENODEV;`
421			`goto out;`
422			`}`
423
424			`adapter_nr = p_os->adapter_nr;`
425
426			`if ((ret = remove_entity(file->private_data))) {`
427			`goto out;`
428			`}`
429
430			`if (divas_um_idi_delete_entity`
431			`((int) adapter_nr, file->private_data)) {`
432			`ret = -ENODEV;`
433			`goto out;`
434			`}`
435
436			`out:`
437			`return (ret);`
438			`}`
439
440			`int diva_os_get_context_size(void)`
441			`{`
442			`return (sizeof(diva_um_idi_os_context_t));`
443			`}`
444
445			`void diva_os_wakeup_read(void *os_context)`
446			`{`
447			`diva_um_idi_os_context_t *p_os =`
448			`(diva_um_idi_os_context_t *) os_context;`
449			`wake_up_interruptible(&p_os->read_wait);`
450			`}`
451
452			`void diva_os_wakeup_close(void *os_context)`
453			`{`
454			`diva_um_idi_os_context_t *p_os =`
455			`(diva_um_idi_os_context_t *) os_context;`
456			`wake_up_interruptible(&p_os->close_wait);`
457			`}`
458
459			`static`
460			`void diva_um_timer_function(unsigned long data)`
461			`{`
462			`diva_um_idi_os_context_t p_os = (diva_um_idi_os_context_t ) data;`
463
464			`p_os->aborted = 1;`
465			`wake_up_interruptible(&p_os->read_wait);`
466			`wake_up_interruptible(&p_os->close_wait);`
467			`DBG_ERR(("entity removal watchdog"))`
468			`}`
469
470			`/*`
471			`** If application exits without entity removal this function will remove`
472			`** entity and block until removal is complete`
473			`*/`
474			`static int remove_entity(void *entity)`
475			`{`
476			`struct task_struct *curtask = current;`
477			`diva_um_idi_os_context_t *p_os;`
478
479			`diva_um_idi_stop_wdog(entity);`
480
481			`if (!entity) {`
482			`DBG_FTL(("Zero entity on remove"))`
483			`return (0);`
484			`}`
485
486			`if (!(p_os =`
487			`(diva_um_idi_os_context_t *)`
488			`diva_um_id_get_os_context(entity))) {`
489			`DBG_FTL(("Zero entity os context on remove"))`
490			`return (0);`
491			`}`
492
493			`if (!divas_um_idi_entity_assigned(entity) \|\| p_os->aborted) {`
494			`/*`
495			`Entity is not assigned, also can be removed`
496			`*/`
497			`return (0);`
498			`}`
499
500			`DBG_TRC(("E(%08x) check remove", entity))`
501
502			`/*`
503			`If adapter not answers on remove request inside of`
504			`10 Sec, then adapter is dead`
505			`*/`
506			`diva_um_idi_start_wdog(entity);`
507
508			`{`
509			`DECLARE_WAITQUEUE(wait, curtask);`
510
511			`add_wait_queue(&p_os->close_wait, &wait);`
512			`for (;;) {`
513			`set_current_state(TASK_INTERRUPTIBLE);`
514			`if (!divas_um_idi_entity_start_remove(entity)`
515			`\|\| p_os->aborted) {`
516			`break;`
517			`}`
518			`schedule();`
519			`}`
520			`set_current_state(TASK_RUNNING);`
521			`remove_wait_queue(&p_os->close_wait, &wait);`
522			`}`
523
524			`DBG_TRC(("E(%08x) start remove", entity))`
525			`{`
526			`DECLARE_WAITQUEUE(wait, curtask);`
527
528			`add_wait_queue(&p_os->close_wait, &wait);`
529			`for (;;) {`
530			`set_current_state(TASK_INTERRUPTIBLE);`
531			`if (!divas_um_idi_entity_assigned(entity)`
532			`\|\| p_os->aborted) {`
533			`break;`
534			`}`
535			`schedule();`
536			`}`
537			`set_current_state(TASK_RUNNING);`
538			`remove_wait_queue(&p_os->close_wait, &wait);`
539			`}`
540
541			`DBG_TRC(("E(%08x) remove complete, aborted:%d", entity,`
542			`p_os->aborted))`
543
544			`diva_um_idi_stop_wdog(entity);`
545
546			`p_os->aborted = 0;`
547
548			`return (0);`
549			`}`
550
551			`/*`
552			`* timer watchdog`
553			`*/`
554			`void diva_um_idi_start_wdog(void *entity)`
555			`{`
556			`diva_um_idi_os_context_t *p_os;`
557
558			`if (entity &&`
559			`((p_os =`
560			`(diva_um_idi_os_context_t *)`
561			`diva_um_id_get_os_context(entity)))) {`
562			`mod_timer(&p_os->diva_timer_id, jiffies + 10 * HZ);`
563			`}`
564			`}`
565
566			`void diva_um_idi_stop_wdog(void *entity)`
567			`{`
568			`diva_um_idi_os_context_t *p_os;`
569
570			`if (entity &&`
571			`((p_os =`
572			`(diva_um_idi_os_context_t *)`
573			`diva_um_id_get_os_context(entity)))) {`
574			`del_timer(&p_os->diva_timer_id);`
575			`}`
576			`}`