GNU Linux-libre 4.4.284-gnu1
[releases.git] / 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 <linux/seq_file.h>
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 um_idi_proc_show(struct seq_file *m, void *v)
90 {
91         char tmprev[32];
92
93         seq_printf(m, "%s\n", DRIVERNAME);
94         seq_printf(m, "name     : %s\n", DRIVERLNAME);
95         seq_printf(m, "release  : %s\n", DRIVERRELEASE_IDI);
96         strcpy(tmprev, main_revision);
97         seq_printf(m, "revision : %s\n", getrev(tmprev));
98         seq_printf(m, "build    : %s\n", DIVA_BUILD);
99         seq_printf(m, "major    : %d\n", major);
100
101         return 0;
102 }
103
104 static int um_idi_proc_open(struct inode *inode, struct file *file)
105 {
106         return single_open(file, um_idi_proc_show, NULL);
107 }
108
109 static const struct file_operations um_idi_proc_fops = {
110         .owner          = THIS_MODULE,
111         .open           = um_idi_proc_open,
112         .read           = seq_read,
113         .llseek         = seq_lseek,
114         .release        = single_release,
115 };
116
117 static int __init create_um_idi_proc(void)
118 {
119         um_idi_proc_entry = proc_create(DRIVERLNAME, S_IRUGO, proc_net_eicon,
120                                         &um_idi_proc_fops);
121         if (!um_idi_proc_entry)
122                 return (0);
123         return (1);
124 }
125
126 static void remove_um_idi_proc(void)
127 {
128         if (um_idi_proc_entry) {
129                 remove_proc_entry(DRIVERLNAME, proc_net_eicon);
130                 um_idi_proc_entry = NULL;
131         }
132 }
133
134 static const struct file_operations divas_idi_fops = {
135         .owner   = THIS_MODULE,
136         .llseek  = no_llseek,
137         .read    = um_idi_read,
138         .write   = um_idi_write,
139         .poll    = um_idi_poll,
140         .open    = um_idi_open,
141         .release = um_idi_release
142 };
143
144 static void divas_idi_unregister_chrdev(void)
145 {
146         unregister_chrdev(major, DEVNAME);
147 }
148
149 static int __init divas_idi_register_chrdev(void)
150 {
151         if ((major = register_chrdev(0, DEVNAME, &divas_idi_fops)) < 0)
152         {
153                 printk(KERN_ERR "%s: failed to create /dev entry.\n",
154                        DRIVERLNAME);
155                 return (0);
156         }
157
158         return (1);
159 }
160
161 /*
162 ** Driver Load
163 */
164 static int __init divasi_init(void)
165 {
166         char tmprev[50];
167         int ret = 0;
168
169         printk(KERN_INFO "%s\n", DRIVERNAME);
170         printk(KERN_INFO "%s: Rel:%s  Rev:", DRIVERLNAME, DRIVERRELEASE_IDI);
171         strcpy(tmprev, main_revision);
172         printk("%s  Build: %s\n", getrev(tmprev), DIVA_BUILD);
173
174         if (!divas_idi_register_chrdev()) {
175                 ret = -EIO;
176                 goto out;
177         }
178
179         if (!create_um_idi_proc()) {
180                 divas_idi_unregister_chrdev();
181                 printk(KERN_ERR "%s: failed to create proc entry.\n",
182                        DRIVERLNAME);
183                 ret = -EIO;
184                 goto out;
185         }
186
187         if (!(idifunc_init())) {
188                 remove_um_idi_proc();
189                 divas_idi_unregister_chrdev();
190                 printk(KERN_ERR "%s: failed to connect to DIDD.\n",
191                        DRIVERLNAME);
192                 ret = -EIO;
193                 goto out;
194         }
195         printk(KERN_INFO "%s: started with major %d\n", DRIVERLNAME, major);
196
197 out:
198         return (ret);
199 }
200
201
202 /*
203 ** Driver Unload
204 */
205 static void __exit divasi_exit(void)
206 {
207         idifunc_finit();
208         remove_um_idi_proc();
209         divas_idi_unregister_chrdev();
210
211         printk(KERN_INFO "%s: module unloaded.\n", DRIVERLNAME);
212 }
213
214 module_init(divasi_init);
215 module_exit(divasi_exit);
216
217
218 /*
219  *  FILE OPERATIONS
220  */
221
222 static int
223 divas_um_idi_copy_to_user(void *os_handle, void *dst, const void *src,
224                           int length)
225 {
226         memcpy(dst, src, length);
227         return (length);
228 }
229
230 static ssize_t
231 um_idi_read(struct file *file, char __user *buf, size_t count, loff_t *offset)
232 {
233         diva_um_idi_os_context_t *p_os;
234         int ret = -EINVAL;
235         void *data;
236
237         if (!file->private_data) {
238                 return (-ENODEV);
239         }
240
241         if (!
242             (p_os =
243              (diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
244                                                                     private_data)))
245         {
246                 return (-ENODEV);
247         }
248         if (p_os->aborted) {
249                 return (-ENODEV);
250         }
251
252         if (!(data = diva_os_malloc(0, count))) {
253                 return (-ENOMEM);
254         }
255
256         ret = diva_um_idi_read(file->private_data,
257                                file, data, count,
258                                divas_um_idi_copy_to_user);
259         switch (ret) {
260         case 0:         /* no message available */
261                 ret = (-EAGAIN);
262                 break;
263         case (-1):              /* adapter was removed */
264                 ret = (-ENODEV);
265                 break;
266         case (-2):              /* message_length > length of user buffer */
267                 ret = (-EFAULT);
268                 break;
269         }
270
271         if (ret > 0) {
272                 if (copy_to_user(buf, data, ret)) {
273                         ret = (-EFAULT);
274                 }
275         }
276
277         diva_os_free(0, data);
278         DBG_TRC(("read: ret %d", ret));
279         return (ret);
280 }
281
282
283 static int
284 divas_um_idi_copy_from_user(void *os_handle, void *dst, const void *src,
285                             int length)
286 {
287         memcpy(dst, src, length);
288         return (length);
289 }
290
291 static int um_idi_open_adapter(struct file *file, int adapter_nr)
292 {
293         diva_um_idi_os_context_t *p_os;
294         void *e =
295                 divas_um_idi_create_entity((dword) adapter_nr, (void *) file);
296
297         if (!(file->private_data = e)) {
298                 return (0);
299         }
300         p_os = (diva_um_idi_os_context_t *) diva_um_id_get_os_context(e);
301         init_waitqueue_head(&p_os->read_wait);
302         init_waitqueue_head(&p_os->close_wait);
303         init_timer(&p_os->diva_timer_id);
304         p_os->diva_timer_id.function = (void *) diva_um_timer_function;
305         p_os->diva_timer_id.data = (unsigned long) p_os;
306         p_os->aborted = 0;
307         p_os->adapter_nr = adapter_nr;
308         return (1);
309 }
310
311 static ssize_t
312 um_idi_write(struct file *file, const char __user *buf, size_t count,
313              loff_t *offset)
314 {
315         diva_um_idi_os_context_t *p_os;
316         int ret = -EINVAL;
317         void *data;
318         int adapter_nr = 0;
319
320         if (!file->private_data) {
321                 /* the first write() selects the adapter_nr */
322                 if (count == sizeof(int)) {
323                         if (copy_from_user
324                             ((void *) &adapter_nr, buf,
325                              count)) return (-EFAULT);
326                         if (!(um_idi_open_adapter(file, adapter_nr)))
327                                 return (-ENODEV);
328                         return (count);
329                 } else
330                         return (-ENODEV);
331         }
332
333         if (!(p_os =
334               (diva_um_idi_os_context_t *) diva_um_id_get_os_context(file->
335                                                                      private_data)))
336         {
337                 return (-ENODEV);
338         }
339         if (p_os->aborted) {
340                 return (-ENODEV);
341         }
342
343         if (!(data = diva_os_malloc(0, count))) {
344                 return (-ENOMEM);
345         }
346
347         if (copy_from_user(data, buf, count)) {
348                 ret = -EFAULT;
349         } else {
350                 ret = diva_um_idi_write(file->private_data,
351                                         file, data, count,
352                                         divas_um_idi_copy_from_user);
353                 switch (ret) {
354                 case 0: /* no space available */
355                         ret = (-EAGAIN);
356                         break;
357                 case (-1):      /* adapter was removed */
358                         ret = (-ENODEV);
359                         break;
360                 case (-2):      /* length of user buffer > max message_length */
361                         ret = (-EFAULT);
362                         break;
363                 }
364         }
365         diva_os_free(0, data);
366         DBG_TRC(("write: ret %d", ret));
367         return (ret);
368 }
369
370 static unsigned int um_idi_poll(struct file *file, poll_table *wait)
371 {
372         diva_um_idi_os_context_t *p_os;
373
374         if (!file->private_data) {
375                 return (POLLERR);
376         }
377
378         if ((!(p_os =
379                (diva_um_idi_os_context_t *)
380                diva_um_id_get_os_context(file->private_data)))
381             || p_os->aborted) {
382                 return (POLLERR);
383         }
384
385         poll_wait(file, &p_os->read_wait, wait);
386
387         if (p_os->aborted) {
388                 return (POLLERR);
389         }
390
391         switch (diva_user_mode_idi_ind_ready(file->private_data, file)) {
392         case (-1):
393                 return (POLLERR);
394
395         case 0:
396                 return (0);
397         }
398
399         return (POLLIN | POLLRDNORM);
400 }
401
402 static int um_idi_open(struct inode *inode, struct file *file)
403 {
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 }