Merge git://git.kernel.org/pub/scm/linux/kernel/git/aegl/linux-2.6
[linux-2.6] / drivers / isdn / hardware / eicon / divasi.c
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
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 }