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  */
getrev(const char * revision)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 
um_idi_proc_show(struct seq_file * m,void * v)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 
um_idi_proc_open(struct inode * inode,struct file * file)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 
create_um_idi_proc(void)117 static int DIVA_INIT_FUNCTION 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 
remove_um_idi_proc(void)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 
divas_idi_unregister_chrdev(void)144 static void divas_idi_unregister_chrdev(void)
145 {
146 	unregister_chrdev(major, DEVNAME);
147 }
148 
divas_idi_register_chrdev(void)149 static int DIVA_INIT_FUNCTION 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 */
divasi_init(void)164 static int DIVA_INIT_FUNCTION 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 */
divasi_exit(void)205 static void DIVA_EXIT_FUNCTION 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
divas_um_idi_copy_to_user(void * os_handle,void * dst,const void * src,int length)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
um_idi_read(struct file * file,char __user * buf,size_t count,loff_t * offset)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
divas_um_idi_copy_from_user(void * os_handle,void * dst,const void * src,int length)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 
um_idi_open_adapter(struct file * file,int adapter_nr)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
um_idi_write(struct file * file,const char __user * buf,size_t count,loff_t * offset)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 
um_idi_poll(struct file * file,poll_table * wait)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 
um_idi_open(struct inode * inode,struct file * file)402 static int um_idi_open(struct inode *inode, struct file *file)
403 {
404 	return (0);
405 }
406 
407 
um_idi_release(struct inode * inode,struct file * file)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 
diva_os_get_context_size(void)441 int diva_os_get_context_size(void)
442 {
443 	return (sizeof(diva_um_idi_os_context_t));
444 }
445 
diva_os_wakeup_read(void * os_context)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 
diva_os_wakeup_close(void * os_context)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
diva_um_timer_function(unsigned long data)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 */
remove_entity(void * entity)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  */
diva_um_idi_start_wdog(void * entity)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 
diva_um_idi_stop_wdog(void * entity)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 }
578