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 }
577
|
This page was automatically generated by the
LXR engine.
|