1 /* $Id: capi.c,v 1.1.2.7 2004/04/28 09:48:59 armin Exp $
3 * CAPI 2.0 Interface for Linux
5 * Copyright 1996 by Carsten Paeth <calle@calle.de>
7 * This software may be used and distributed according to the terms
8 * of the GNU General Public License, incorporated herein by reference.
12 #include <linux/module.h>
13 #include <linux/errno.h>
14 #include <linux/kernel.h>
15 #include <linux/major.h>
16 #include <linux/sched.h>
17 #include <linux/slab.h>
18 #include <linux/fcntl.h>
20 #include <linux/signal.h>
21 #include <linux/mutex.h>
23 #include <linux/smp_lock.h>
24 #include <linux/timer.h>
25 #include <linux/wait.h>
26 #include <linux/tty.h>
27 #include <linux/netdevice.h>
28 #include <linux/ppp_defs.h>
29 #include <linux/if_ppp.h>
30 #include <linux/skbuff.h>
31 #include <linux/proc_fs.h>
32 #include <linux/seq_file.h>
33 #include <linux/poll.h>
34 #include <linux/capi.h>
35 #include <linux/kernelcapi.h>
36 #include <linux/init.h>
37 #include <linux/device.h>
38 #include <linux/moduleparam.h>
39 #include <linux/isdn/capiutil.h>
40 #include <linux/isdn/capicmd.h>
44 MODULE_DESCRIPTION("CAPI4Linux: Userspace /dev/capi20 interface");
45 MODULE_AUTHOR("Carsten Paeth");
46 MODULE_LICENSE("GPL");
48 #undef _DEBUG_REFCOUNT /* alloc/free and open/close debug */
49 #undef _DEBUG_TTYFUNCS /* call to tty_driver */
50 #undef _DEBUG_DATAFLOW /* data flow */
52 /* -------- driver information -------------------------------------- */
54 static struct class *capi_class
;
55 static int capi_major
= 68; /* allocated */
57 module_param_named(major
, capi_major
, uint
, 0);
59 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
60 #define CAPINC_NR_PORTS 32
61 #define CAPINC_MAX_PORTS 256
63 static int capi_ttymajor
= 191;
64 static int capi_ttyminors
= CAPINC_NR_PORTS
;
66 module_param_named(ttymajor
, capi_ttymajor
, uint
, 0);
67 module_param_named(ttyminors
, capi_ttyminors
, uint
, 0);
68 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
70 /* -------- defines ------------------------------------------------- */
72 #define CAPINC_MAX_RECVQUEUE 10
73 #define CAPINC_MAX_SENDQUEUE 10
74 #define CAPI_MAX_BLKSIZE 2048
76 /* -------- data structures ----------------------------------------- */
82 struct datahandle_queue
{
83 struct list_head list
;
88 struct list_head list
;
89 struct capincci
*nccip
;
91 struct dentry
*capifs_dentry
;
93 struct capi20_appl
*ap
;
98 struct tty_struct
*tty
;
101 struct sk_buff
*ttyskb
;
102 atomic_t ttyopencount
;
104 struct sk_buff_head inqueue
;
106 struct sk_buff_head outqueue
;
110 struct list_head ackqueue
;
115 /* FIXME: The following lock is a sledgehammer-workaround to a
116 * locking issue with the capiminor (and maybe other) data structure(s).
117 * Access to this data is done in a racy way and crashes the machine with
118 * a FritzCard DSL driver; sooner or later. This is a workaround
119 * which trades scalability vs stability, so it doesn't crash the kernel anymore.
120 * The correct (and scalable) fix for the issue seems to require
121 * an API change to the drivers... . */
122 static DEFINE_SPINLOCK(workaround_lock
);
125 struct capincci
*next
;
127 struct capidev
*cdev
;
128 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
129 struct capiminor
*minorp
;
130 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
134 struct list_head list
;
135 struct capi20_appl ap
;
139 struct sk_buff_head recvqueue
;
140 wait_queue_head_t recvwait
;
142 struct capincci
*nccis
;
144 struct mutex ncci_list_mtx
;
147 /* -------- global variables ---------------------------------------- */
149 static DEFINE_MUTEX(capidev_list_lock
);
150 static LIST_HEAD(capidev_list
);
152 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
154 static DEFINE_RWLOCK(capiminor_list_lock
);
155 static LIST_HEAD(capiminor_list
);
157 /* -------- datahandles --------------------------------------------- */
159 static int capiminor_add_ack(struct capiminor
*mp
, u16 datahandle
)
161 struct datahandle_queue
*n
;
164 n
= kmalloc(sizeof(*n
), GFP_ATOMIC
);
166 printk(KERN_ERR
"capi: alloc datahandle failed\n");
169 n
->datahandle
= datahandle
;
170 INIT_LIST_HEAD(&n
->list
);
171 spin_lock_irqsave(&mp
->ackqlock
, flags
);
172 list_add_tail(&n
->list
, &mp
->ackqueue
);
174 spin_unlock_irqrestore(&mp
->ackqlock
, flags
);
178 static int capiminor_del_ack(struct capiminor
*mp
, u16 datahandle
)
180 struct datahandle_queue
*p
, *tmp
;
183 spin_lock_irqsave(&mp
->ackqlock
, flags
);
184 list_for_each_entry_safe(p
, tmp
, &mp
->ackqueue
, list
) {
185 if (p
->datahandle
== datahandle
) {
189 spin_unlock_irqrestore(&mp
->ackqlock
, flags
);
193 spin_unlock_irqrestore(&mp
->ackqlock
, flags
);
197 static void capiminor_del_all_ack(struct capiminor
*mp
)
199 struct datahandle_queue
*p
, *tmp
;
202 spin_lock_irqsave(&mp
->ackqlock
, flags
);
203 list_for_each_entry_safe(p
, tmp
, &mp
->ackqueue
, list
) {
208 spin_unlock_irqrestore(&mp
->ackqlock
, flags
);
212 /* -------- struct capiminor ---------------------------------------- */
214 static struct capiminor
*capiminor_alloc(struct capi20_appl
*ap
, u32 ncci
)
216 struct capiminor
*mp
, *p
;
217 unsigned int minor
= 0;
220 mp
= kzalloc(sizeof(*mp
), GFP_ATOMIC
);
222 printk(KERN_ERR
"capi: can't alloc capiminor\n");
229 atomic_set(&mp
->ttyopencount
,0);
230 INIT_LIST_HEAD(&mp
->ackqueue
);
231 spin_lock_init(&mp
->ackqlock
);
233 skb_queue_head_init(&mp
->inqueue
);
234 skb_queue_head_init(&mp
->outqueue
);
236 /* Allocate the least unused minor number.
238 write_lock_irqsave(&capiminor_list_lock
, flags
);
239 if (list_empty(&capiminor_list
))
240 list_add(&mp
->list
, &capiminor_list
);
242 list_for_each_entry(p
, &capiminor_list
, list
) {
243 if (p
->minor
> minor
)
248 if (minor
< capi_ttyminors
) {
250 list_add(&mp
->list
, p
->list
.prev
);
253 write_unlock_irqrestore(&capiminor_list_lock
, flags
);
255 if (!(minor
< capi_ttyminors
)) {
256 printk(KERN_NOTICE
"capi: out of minors\n");
264 static void capiminor_free(struct capiminor
*mp
)
268 write_lock_irqsave(&capiminor_list_lock
, flags
);
270 write_unlock_irqrestore(&capiminor_list_lock
, flags
);
272 kfree_skb(mp
->ttyskb
);
274 skb_queue_purge(&mp
->inqueue
);
275 skb_queue_purge(&mp
->outqueue
);
276 capiminor_del_all_ack(mp
);
280 static struct capiminor
*capiminor_find(unsigned int minor
)
283 struct capiminor
*p
= NULL
;
285 read_lock(&capiminor_list_lock
);
286 list_for_each(l
, &capiminor_list
) {
287 p
= list_entry(l
, struct capiminor
, list
);
288 if (p
->minor
== minor
)
291 read_unlock(&capiminor_list_lock
);
292 if (l
== &capiminor_list
)
298 /* -------- struct capincci ----------------------------------------- */
300 static void capincci_alloc_minor(struct capidev
*cdev
, struct capincci
*np
)
302 struct capiminor
*mp
;
304 if (!(cdev
->userflags
& CAPIFLAG_HIGHJACKING
))
307 mp
= np
->minorp
= capiminor_alloc(&cdev
->ap
, np
->ncci
);
310 #ifdef _DEBUG_REFCOUNT
311 printk(KERN_DEBUG
"set mp->nccip\n");
314 capifs_new_ncci(mp
->minor
,
315 MKDEV(capi_ttymajor
, mp
->minor
));
319 static void capincci_free_minor(struct capincci
*np
)
321 struct capiminor
*mp
= np
->minorp
;
324 capifs_free_ncci(mp
->capifs_dentry
);
327 #ifdef _DEBUG_REFCOUNT
328 printk(KERN_DEBUG
"reset mp->nccip\n");
337 static inline unsigned int capincci_minor_opencount(struct capincci
*np
)
339 struct capiminor
*mp
= np
->minorp
;
341 return mp
? atomic_read(&mp
->ttyopencount
) : 0;
344 #else /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
347 capincci_alloc_minor(struct capidev
*cdev
, struct capincci
*np
) { }
348 static inline void capincci_free_minor(struct capincci
*np
) { }
350 static inline unsigned int capincci_minor_opencount(struct capincci
*np
)
355 #endif /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
357 static struct capincci
*capincci_alloc(struct capidev
*cdev
, u32 ncci
)
359 struct capincci
*np
, **pp
;
361 np
= kzalloc(sizeof(*np
), GFP_ATOMIC
);
367 capincci_alloc_minor(cdev
, np
);
369 for (pp
=&cdev
->nccis
; *pp
; pp
= &(*pp
)->next
)
375 static void capincci_free(struct capidev
*cdev
, u32 ncci
)
377 struct capincci
*np
, **pp
;
382 if (ncci
== 0xffffffff || np
->ncci
== ncci
) {
384 capincci_free_minor(np
);
386 if (*pp
== NULL
) return;
393 static struct capincci
*capincci_find(struct capidev
*cdev
, u32 ncci
)
397 for (p
=cdev
->nccis
; p
; p
= p
->next
) {
404 /* -------- struct capidev ------------------------------------------ */
406 static struct capidev
*capidev_alloc(void)
408 struct capidev
*cdev
;
410 cdev
= kzalloc(sizeof(*cdev
), GFP_KERNEL
);
414 mutex_init(&cdev
->ncci_list_mtx
);
415 skb_queue_head_init(&cdev
->recvqueue
);
416 init_waitqueue_head(&cdev
->recvwait
);
418 mutex_lock(&capidev_list_lock
);
419 list_add_tail(&cdev
->list
, &capidev_list
);
420 mutex_unlock(&capidev_list_lock
);
425 static void capidev_free(struct capidev
*cdev
)
427 mutex_lock(&capidev_list_lock
);
428 list_del(&cdev
->list
);
429 mutex_unlock(&capidev_list_lock
);
431 if (cdev
->ap
.applid
) {
432 capi20_release(&cdev
->ap
);
435 skb_queue_purge(&cdev
->recvqueue
);
437 mutex_lock(&cdev
->ncci_list_mtx
);
438 capincci_free(cdev
, 0xffffffff);
439 mutex_unlock(&cdev
->ncci_list_mtx
);
444 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
445 /* -------- handle data queue --------------------------------------- */
447 static struct sk_buff
*
448 gen_data_b3_resp_for(struct capiminor
*mp
, struct sk_buff
*skb
)
450 struct sk_buff
*nskb
;
451 nskb
= alloc_skb(CAPI_DATA_B3_RESP_LEN
, GFP_ATOMIC
);
453 u16 datahandle
= CAPIMSG_U16(skb
->data
,CAPIMSG_BASELEN
+4+4+2);
454 unsigned char *s
= skb_put(nskb
, CAPI_DATA_B3_RESP_LEN
);
455 capimsg_setu16(s
, 0, CAPI_DATA_B3_RESP_LEN
);
456 capimsg_setu16(s
, 2, mp
->ap
->applid
);
457 capimsg_setu8 (s
, 4, CAPI_DATA_B3
);
458 capimsg_setu8 (s
, 5, CAPI_RESP
);
459 capimsg_setu16(s
, 6, mp
->msgid
++);
460 capimsg_setu32(s
, 8, mp
->ncci
);
461 capimsg_setu16(s
, 12, datahandle
);
466 static int handle_recv_skb(struct capiminor
*mp
, struct sk_buff
*skb
)
468 struct sk_buff
*nskb
;
470 u16 errcode
, datahandle
;
471 struct tty_ldisc
*ld
;
473 datalen
= skb
->len
- CAPIMSG_LEN(skb
->data
);
476 #ifdef _DEBUG_DATAFLOW
477 printk(KERN_DEBUG
"capi: currently no receiver\n");
482 ld
= tty_ldisc_ref(mp
->tty
);
485 if (ld
->ops
->receive_buf
== NULL
) {
486 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
487 printk(KERN_DEBUG
"capi: ldisc has no receive_buf function\n");
492 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
493 printk(KERN_DEBUG
"capi: recv tty throttled\n");
497 if (mp
->tty
->receive_room
< datalen
) {
498 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
499 printk(KERN_DEBUG
"capi: no room in tty\n");
503 if ((nskb
= gen_data_b3_resp_for(mp
, skb
)) == NULL
) {
504 printk(KERN_ERR
"capi: gen_data_b3_resp failed\n");
507 datahandle
= CAPIMSG_U16(skb
->data
,CAPIMSG_BASELEN
+4);
508 errcode
= capi20_put_message(mp
->ap
, nskb
);
509 if (errcode
!= CAPI_NOERROR
) {
510 printk(KERN_ERR
"capi: send DATA_B3_RESP failed=%x\n",
515 (void)skb_pull(skb
, CAPIMSG_LEN(skb
->data
));
516 #ifdef _DEBUG_DATAFLOW
517 printk(KERN_DEBUG
"capi: DATA_B3_RESP %u len=%d => ldisc\n",
518 datahandle
, skb
->len
);
520 ld
->ops
->receive_buf(mp
->tty
, skb
->data
, NULL
, skb
->len
);
529 static void handle_minor_recv(struct capiminor
*mp
)
532 while ((skb
= skb_dequeue(&mp
->inqueue
)) != NULL
) {
533 unsigned int len
= skb
->len
;
535 if (handle_recv_skb(mp
, skb
) < 0) {
536 skb_queue_head(&mp
->inqueue
, skb
);
543 static int handle_minor_send(struct capiminor
*mp
)
551 if (mp
->tty
&& mp
->ttyoutstop
) {
552 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
553 printk(KERN_DEBUG
"capi: send: tty stopped\n");
558 while ((skb
= skb_dequeue(&mp
->outqueue
)) != NULL
) {
559 datahandle
= mp
->datahandle
;
561 skb_push(skb
, CAPI_DATA_B3_REQ_LEN
);
562 memset(skb
->data
, 0, CAPI_DATA_B3_REQ_LEN
);
563 capimsg_setu16(skb
->data
, 0, CAPI_DATA_B3_REQ_LEN
);
564 capimsg_setu16(skb
->data
, 2, mp
->ap
->applid
);
565 capimsg_setu8 (skb
->data
, 4, CAPI_DATA_B3
);
566 capimsg_setu8 (skb
->data
, 5, CAPI_REQ
);
567 capimsg_setu16(skb
->data
, 6, mp
->msgid
++);
568 capimsg_setu32(skb
->data
, 8, mp
->ncci
); /* NCCI */
569 capimsg_setu32(skb
->data
, 12, (u32
)(long)skb
->data
);/* Data32 */
570 capimsg_setu16(skb
->data
, 16, len
); /* Data length */
571 capimsg_setu16(skb
->data
, 18, datahandle
);
572 capimsg_setu16(skb
->data
, 20, 0); /* Flags */
574 if (capiminor_add_ack(mp
, datahandle
) < 0) {
575 skb_pull(skb
, CAPI_DATA_B3_REQ_LEN
);
576 skb_queue_head(&mp
->outqueue
, skb
);
579 errcode
= capi20_put_message(mp
->ap
, skb
);
580 if (errcode
== CAPI_NOERROR
) {
584 #ifdef _DEBUG_DATAFLOW
585 printk(KERN_DEBUG
"capi: DATA_B3_REQ %u len=%u\n",
590 capiminor_del_ack(mp
, datahandle
);
592 if (errcode
== CAPI_SENDQUEUEFULL
) {
593 skb_pull(skb
, CAPI_DATA_B3_REQ_LEN
);
594 skb_queue_head(&mp
->outqueue
, skb
);
598 /* ups, drop packet */
599 printk(KERN_ERR
"capi: put_message = %x\n", errcode
);
606 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
607 /* -------- function called by lower level -------------------------- */
609 static void capi_recv_message(struct capi20_appl
*ap
, struct sk_buff
*skb
)
611 struct capidev
*cdev
= ap
->private;
612 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
613 struct capiminor
*mp
;
615 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
620 if (CAPIMSG_CMD(skb
->data
) == CAPI_CONNECT_B3_CONF
) {
621 u16 info
= CAPIMSG_U16(skb
->data
, 12); // Info field
622 if ((info
& 0xff00) == 0) {
623 mutex_lock(&cdev
->ncci_list_mtx
);
624 capincci_alloc(cdev
, CAPIMSG_NCCI(skb
->data
));
625 mutex_unlock(&cdev
->ncci_list_mtx
);
628 if (CAPIMSG_CMD(skb
->data
) == CAPI_CONNECT_B3_IND
) {
629 mutex_lock(&cdev
->ncci_list_mtx
);
630 capincci_alloc(cdev
, CAPIMSG_NCCI(skb
->data
));
631 mutex_unlock(&cdev
->ncci_list_mtx
);
633 spin_lock_irqsave(&workaround_lock
, flags
);
634 if (CAPIMSG_COMMAND(skb
->data
) != CAPI_DATA_B3
) {
635 skb_queue_tail(&cdev
->recvqueue
, skb
);
636 wake_up_interruptible(&cdev
->recvwait
);
637 spin_unlock_irqrestore(&workaround_lock
, flags
);
640 ncci
= CAPIMSG_CONTROL(skb
->data
);
641 for (np
= cdev
->nccis
; np
&& np
->ncci
!= ncci
; np
= np
->next
)
644 printk(KERN_ERR
"BUG: capi_signal: ncci not found\n");
645 skb_queue_tail(&cdev
->recvqueue
, skb
);
646 wake_up_interruptible(&cdev
->recvwait
);
647 spin_unlock_irqrestore(&workaround_lock
, flags
);
651 #ifndef CONFIG_ISDN_CAPI_MIDDLEWARE
652 skb_queue_tail(&cdev
->recvqueue
, skb
);
653 wake_up_interruptible(&cdev
->recvwait
);
655 #else /* CONFIG_ISDN_CAPI_MIDDLEWARE */
659 skb_queue_tail(&cdev
->recvqueue
, skb
);
660 wake_up_interruptible(&cdev
->recvwait
);
661 spin_unlock_irqrestore(&workaround_lock
, flags
);
664 if (CAPIMSG_SUBCOMMAND(skb
->data
) == CAPI_IND
) {
665 datahandle
= CAPIMSG_U16(skb
->data
, CAPIMSG_BASELEN
+4+4+2);
666 #ifdef _DEBUG_DATAFLOW
667 printk(KERN_DEBUG
"capi_signal: DATA_B3_IND %u len=%d\n",
668 datahandle
, skb
->len
-CAPIMSG_LEN(skb
->data
));
670 skb_queue_tail(&mp
->inqueue
, skb
);
671 mp
->inbytes
+= skb
->len
;
672 handle_minor_recv(mp
);
674 } else if (CAPIMSG_SUBCOMMAND(skb
->data
) == CAPI_CONF
) {
676 datahandle
= CAPIMSG_U16(skb
->data
, CAPIMSG_BASELEN
+4);
677 #ifdef _DEBUG_DATAFLOW
678 printk(KERN_DEBUG
"capi_signal: DATA_B3_CONF %u 0x%x\n",
680 CAPIMSG_U16(skb
->data
, CAPIMSG_BASELEN
+4+2));
683 (void)capiminor_del_ack(mp
, datahandle
);
686 (void)handle_minor_send(mp
);
689 /* ups, let capi application handle it :-) */
690 skb_queue_tail(&cdev
->recvqueue
, skb
);
691 wake_up_interruptible(&cdev
->recvwait
);
693 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
695 spin_unlock_irqrestore(&workaround_lock
, flags
);
698 /* -------- file_operations for capidev ----------------------------- */
701 capi_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
703 struct capidev
*cdev
= (struct capidev
*)file
->private_data
;
707 if (!cdev
->ap
.applid
)
710 if ((skb
= skb_dequeue(&cdev
->recvqueue
)) == NULL
) {
712 if (file
->f_flags
& O_NONBLOCK
)
716 interruptible_sleep_on(&cdev
->recvwait
);
717 if ((skb
= skb_dequeue(&cdev
->recvqueue
)) != NULL
)
719 if (signal_pending(current
))
723 return -ERESTARTNOHAND
;
725 if (skb
->len
> count
) {
726 skb_queue_head(&cdev
->recvqueue
, skb
);
729 if (copy_to_user(buf
, skb
->data
, skb
->len
)) {
730 skb_queue_head(&cdev
->recvqueue
, skb
);
741 capi_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
743 struct capidev
*cdev
= (struct capidev
*)file
->private_data
;
747 if (!cdev
->ap
.applid
)
750 skb
= alloc_skb(count
, GFP_USER
);
754 if (copy_from_user(skb_put(skb
, count
), buf
, count
)) {
758 mlen
= CAPIMSG_LEN(skb
->data
);
759 if (CAPIMSG_CMD(skb
->data
) == CAPI_DATA_B3_REQ
) {
760 if ((size_t)(mlen
+ CAPIMSG_DATALEN(skb
->data
)) != count
) {
770 CAPIMSG_SETAPPID(skb
->data
, cdev
->ap
.applid
);
772 if (CAPIMSG_CMD(skb
->data
) == CAPI_DISCONNECT_B3_RESP
) {
773 mutex_lock(&cdev
->ncci_list_mtx
);
774 capincci_free(cdev
, CAPIMSG_NCCI(skb
->data
));
775 mutex_unlock(&cdev
->ncci_list_mtx
);
778 cdev
->errcode
= capi20_put_message(&cdev
->ap
, skb
);
788 capi_poll(struct file
*file
, poll_table
* wait
)
790 struct capidev
*cdev
= (struct capidev
*)file
->private_data
;
791 unsigned int mask
= 0;
793 if (!cdev
->ap
.applid
)
796 poll_wait(file
, &(cdev
->recvwait
), wait
);
797 mask
= POLLOUT
| POLLWRNORM
;
798 if (!skb_queue_empty(&cdev
->recvqueue
))
799 mask
|= POLLIN
| POLLRDNORM
;
804 capi_ioctl(struct inode
*inode
, struct file
*file
,
805 unsigned int cmd
, unsigned long arg
)
807 struct capidev
*cdev
= file
->private_data
;
808 struct capi20_appl
*ap
= &cdev
->ap
;
809 capi_ioctl_struct data
;
810 int retval
= -EINVAL
;
811 void __user
*argp
= (void __user
*)arg
;
819 if (copy_from_user(&cdev
->ap
.rparam
, argp
,
820 sizeof(struct capi_register_params
)))
823 cdev
->ap
.private = cdev
;
824 cdev
->ap
.recv_message
= capi_recv_message
;
825 cdev
->errcode
= capi20_register(ap
);
831 return (int)ap
->applid
;
833 case CAPI_GET_VERSION
:
835 if (copy_from_user(&data
.contr
, argp
,
838 cdev
->errcode
= capi20_get_version(data
.contr
, &data
.version
);
841 if (copy_to_user(argp
, &data
.version
,
842 sizeof(data
.version
)))
847 case CAPI_GET_SERIAL
:
849 if (copy_from_user(&data
.contr
, argp
,
852 cdev
->errcode
= capi20_get_serial (data
.contr
, data
.serial
);
855 if (copy_to_user(argp
, data
.serial
,
856 sizeof(data
.serial
)))
860 case CAPI_GET_PROFILE
:
862 if (copy_from_user(&data
.contr
, argp
,
866 if (data
.contr
== 0) {
867 cdev
->errcode
= capi20_get_profile(data
.contr
, &data
.profile
);
871 retval
= copy_to_user(argp
,
872 &data
.profile
.ncontroller
,
873 sizeof(data
.profile
.ncontroller
));
876 cdev
->errcode
= capi20_get_profile(data
.contr
, &data
.profile
);
880 retval
= copy_to_user(argp
, &data
.profile
,
881 sizeof(data
.profile
));
888 case CAPI_GET_MANUFACTURER
:
890 if (copy_from_user(&data
.contr
, argp
,
893 cdev
->errcode
= capi20_get_manufacturer(data
.contr
, data
.manufacturer
);
897 if (copy_to_user(argp
, data
.manufacturer
,
898 sizeof(data
.manufacturer
)))
903 case CAPI_GET_ERRCODE
:
904 data
.errcode
= cdev
->errcode
;
905 cdev
->errcode
= CAPI_NOERROR
;
907 if (copy_to_user(argp
, &data
.errcode
,
908 sizeof(data
.errcode
)))
914 if (capi20_isinstalled() == CAPI_NOERROR
)
918 case CAPI_MANUFACTURER_CMD
:
920 struct capi_manufacturer_cmd mcmd
;
921 if (!capable(CAP_SYS_ADMIN
))
923 if (copy_from_user(&mcmd
, argp
, sizeof(mcmd
)))
925 return capi20_manufacturer(mcmd
.cmd
, mcmd
.data
);
933 if (copy_from_user(&userflags
, argp
,
936 if (cmd
== CAPI_SET_FLAGS
)
937 cdev
->userflags
|= userflags
;
939 cdev
->userflags
&= ~userflags
;
944 if (copy_to_user(argp
, &cdev
->userflags
,
945 sizeof(cdev
->userflags
)))
949 case CAPI_NCCI_OPENCOUNT
:
951 struct capincci
*nccip
;
954 if (copy_from_user(&ncci
, argp
, sizeof(ncci
)))
957 mutex_lock(&cdev
->ncci_list_mtx
);
958 if ((nccip
= capincci_find(cdev
, (u32
) ncci
)) == NULL
) {
959 mutex_unlock(&cdev
->ncci_list_mtx
);
962 count
+= capincci_minor_opencount(nccip
);
963 mutex_unlock(&cdev
->ncci_list_mtx
);
968 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
969 case CAPI_NCCI_GETUNIT
:
971 struct capincci
*nccip
;
972 struct capiminor
*mp
;
975 if (copy_from_user(&ncci
, argp
,
978 mutex_lock(&cdev
->ncci_list_mtx
);
979 nccip
= capincci_find(cdev
, (u32
) ncci
);
980 if (!nccip
|| (mp
= nccip
->minorp
) == NULL
) {
981 mutex_unlock(&cdev
->ncci_list_mtx
);
985 mutex_unlock(&cdev
->ncci_list_mtx
);
989 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
995 capi_open(struct inode
*inode
, struct file
*file
)
1000 if (file
->private_data
)
1002 else if ((file
->private_data
= capidev_alloc()) == NULL
)
1005 ret
= nonseekable_open(inode
, file
);
1011 capi_release(struct inode
*inode
, struct file
*file
)
1013 struct capidev
*cdev
= (struct capidev
*)file
->private_data
;
1016 file
->private_data
= NULL
;
1021 static const struct file_operations capi_fops
=
1023 .owner
= THIS_MODULE
,
1024 .llseek
= no_llseek
,
1026 .write
= capi_write
,
1028 .ioctl
= capi_ioctl
,
1030 .release
= capi_release
,
1033 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
1034 /* -------- tty_operations for capincci ----------------------------- */
1036 static int capinc_tty_open(struct tty_struct
* tty
, struct file
* file
)
1038 struct capiminor
*mp
;
1039 unsigned long flags
;
1041 if ((mp
= capiminor_find(iminor(file
->f_path
.dentry
->d_inode
))) == NULL
)
1043 if (mp
->nccip
== NULL
)
1046 tty
->driver_data
= (void *)mp
;
1048 spin_lock_irqsave(&workaround_lock
, flags
);
1049 if (atomic_read(&mp
->ttyopencount
) == 0)
1051 atomic_inc(&mp
->ttyopencount
);
1052 #ifdef _DEBUG_REFCOUNT
1053 printk(KERN_DEBUG
"capinc_tty_open ocount=%d\n", atomic_read(&mp
->ttyopencount
));
1055 handle_minor_recv(mp
);
1056 spin_unlock_irqrestore(&workaround_lock
, flags
);
1060 static void capinc_tty_close(struct tty_struct
* tty
, struct file
* file
)
1062 struct capiminor
*mp
;
1064 mp
= (struct capiminor
*)tty
->driver_data
;
1066 if (atomic_dec_and_test(&mp
->ttyopencount
)) {
1067 #ifdef _DEBUG_REFCOUNT
1068 printk(KERN_DEBUG
"capinc_tty_close lastclose\n");
1070 tty
->driver_data
= NULL
;
1073 #ifdef _DEBUG_REFCOUNT
1074 printk(KERN_DEBUG
"capinc_tty_close ocount=%d\n", atomic_read(&mp
->ttyopencount
));
1076 if (mp
->nccip
== NULL
)
1080 #ifdef _DEBUG_REFCOUNT
1081 printk(KERN_DEBUG
"capinc_tty_close\n");
1085 static int capinc_tty_write(struct tty_struct
* tty
,
1086 const unsigned char *buf
, int count
)
1088 struct capiminor
*mp
= (struct capiminor
*)tty
->driver_data
;
1089 struct sk_buff
*skb
;
1090 unsigned long flags
;
1092 #ifdef _DEBUG_TTYFUNCS
1093 printk(KERN_DEBUG
"capinc_tty_write(count=%d)\n", count
);
1096 if (!mp
|| !mp
->nccip
) {
1097 #ifdef _DEBUG_TTYFUNCS
1098 printk(KERN_DEBUG
"capinc_tty_write: mp or mp->ncci NULL\n");
1103 spin_lock_irqsave(&workaround_lock
, flags
);
1107 skb_queue_tail(&mp
->outqueue
, skb
);
1108 mp
->outbytes
+= skb
->len
;
1111 skb
= alloc_skb(CAPI_DATA_B3_REQ_LEN
+count
, GFP_ATOMIC
);
1113 printk(KERN_ERR
"capinc_tty_write: alloc_skb failed\n");
1114 spin_unlock_irqrestore(&workaround_lock
, flags
);
1118 skb_reserve(skb
, CAPI_DATA_B3_REQ_LEN
);
1119 memcpy(skb_put(skb
, count
), buf
, count
);
1121 skb_queue_tail(&mp
->outqueue
, skb
);
1122 mp
->outbytes
+= skb
->len
;
1123 (void)handle_minor_send(mp
);
1124 (void)handle_minor_recv(mp
);
1125 spin_unlock_irqrestore(&workaround_lock
, flags
);
1129 static int capinc_tty_put_char(struct tty_struct
*tty
, unsigned char ch
)
1131 struct capiminor
*mp
= (struct capiminor
*)tty
->driver_data
;
1132 struct sk_buff
*skb
;
1133 unsigned long flags
;
1136 #ifdef _DEBUG_TTYFUNCS
1137 printk(KERN_DEBUG
"capinc_put_char(%u)\n", ch
);
1140 if (!mp
|| !mp
->nccip
) {
1141 #ifdef _DEBUG_TTYFUNCS
1142 printk(KERN_DEBUG
"capinc_tty_put_char: mp or mp->ncci NULL\n");
1147 spin_lock_irqsave(&workaround_lock
, flags
);
1150 if (skb_tailroom(skb
) > 0) {
1151 *(skb_put(skb
, 1)) = ch
;
1152 spin_unlock_irqrestore(&workaround_lock
, flags
);
1156 skb_queue_tail(&mp
->outqueue
, skb
);
1157 mp
->outbytes
+= skb
->len
;
1158 (void)handle_minor_send(mp
);
1160 skb
= alloc_skb(CAPI_DATA_B3_REQ_LEN
+CAPI_MAX_BLKSIZE
, GFP_ATOMIC
);
1162 skb_reserve(skb
, CAPI_DATA_B3_REQ_LEN
);
1163 *(skb_put(skb
, 1)) = ch
;
1166 printk(KERN_ERR
"capinc_put_char: char %u lost\n", ch
);
1169 spin_unlock_irqrestore(&workaround_lock
, flags
);
1173 static void capinc_tty_flush_chars(struct tty_struct
*tty
)
1175 struct capiminor
*mp
= (struct capiminor
*)tty
->driver_data
;
1176 struct sk_buff
*skb
;
1177 unsigned long flags
;
1179 #ifdef _DEBUG_TTYFUNCS
1180 printk(KERN_DEBUG
"capinc_tty_flush_chars\n");
1183 if (!mp
|| !mp
->nccip
) {
1184 #ifdef _DEBUG_TTYFUNCS
1185 printk(KERN_DEBUG
"capinc_tty_flush_chars: mp or mp->ncci NULL\n");
1190 spin_lock_irqsave(&workaround_lock
, flags
);
1194 skb_queue_tail(&mp
->outqueue
, skb
);
1195 mp
->outbytes
+= skb
->len
;
1196 (void)handle_minor_send(mp
);
1198 (void)handle_minor_recv(mp
);
1199 spin_unlock_irqrestore(&workaround_lock
, flags
);
1202 static int capinc_tty_write_room(struct tty_struct
*tty
)
1204 struct capiminor
*mp
= (struct capiminor
*)tty
->driver_data
;
1206 if (!mp
|| !mp
->nccip
) {
1207 #ifdef _DEBUG_TTYFUNCS
1208 printk(KERN_DEBUG
"capinc_tty_write_room: mp or mp->ncci NULL\n");
1212 room
= CAPINC_MAX_SENDQUEUE
-skb_queue_len(&mp
->outqueue
);
1213 room
*= CAPI_MAX_BLKSIZE
;
1214 #ifdef _DEBUG_TTYFUNCS
1215 printk(KERN_DEBUG
"capinc_tty_write_room = %d\n", room
);
1220 static int capinc_tty_chars_in_buffer(struct tty_struct
*tty
)
1222 struct capiminor
*mp
= (struct capiminor
*)tty
->driver_data
;
1223 if (!mp
|| !mp
->nccip
) {
1224 #ifdef _DEBUG_TTYFUNCS
1225 printk(KERN_DEBUG
"capinc_tty_chars_in_buffer: mp or mp->ncci NULL\n");
1229 #ifdef _DEBUG_TTYFUNCS
1230 printk(KERN_DEBUG
"capinc_tty_chars_in_buffer = %d nack=%d sq=%d rq=%d\n",
1231 mp
->outbytes
, mp
->nack
,
1232 skb_queue_len(&mp
->outqueue
),
1233 skb_queue_len(&mp
->inqueue
));
1235 return mp
->outbytes
;
1238 static int capinc_tty_ioctl(struct tty_struct
*tty
, struct file
* file
,
1239 unsigned int cmd
, unsigned long arg
)
1244 error
= n_tty_ioctl_helper(tty
, file
, cmd
, arg
);
1250 static void capinc_tty_set_termios(struct tty_struct
*tty
, struct ktermios
* old
)
1252 #ifdef _DEBUG_TTYFUNCS
1253 printk(KERN_DEBUG
"capinc_tty_set_termios\n");
1257 static void capinc_tty_throttle(struct tty_struct
* tty
)
1259 struct capiminor
*mp
= (struct capiminor
*)tty
->driver_data
;
1260 #ifdef _DEBUG_TTYFUNCS
1261 printk(KERN_DEBUG
"capinc_tty_throttle\n");
1267 static void capinc_tty_unthrottle(struct tty_struct
* tty
)
1269 struct capiminor
*mp
= (struct capiminor
*)tty
->driver_data
;
1270 unsigned long flags
;
1271 #ifdef _DEBUG_TTYFUNCS
1272 printk(KERN_DEBUG
"capinc_tty_unthrottle\n");
1275 spin_lock_irqsave(&workaround_lock
, flags
);
1277 handle_minor_recv(mp
);
1278 spin_unlock_irqrestore(&workaround_lock
, flags
);
1282 static void capinc_tty_stop(struct tty_struct
*tty
)
1284 struct capiminor
*mp
= (struct capiminor
*)tty
->driver_data
;
1285 #ifdef _DEBUG_TTYFUNCS
1286 printk(KERN_DEBUG
"capinc_tty_stop\n");
1293 static void capinc_tty_start(struct tty_struct
*tty
)
1295 struct capiminor
*mp
= (struct capiminor
*)tty
->driver_data
;
1296 unsigned long flags
;
1297 #ifdef _DEBUG_TTYFUNCS
1298 printk(KERN_DEBUG
"capinc_tty_start\n");
1301 spin_lock_irqsave(&workaround_lock
, flags
);
1303 (void)handle_minor_send(mp
);
1304 spin_unlock_irqrestore(&workaround_lock
, flags
);
1308 static void capinc_tty_hangup(struct tty_struct
*tty
)
1310 #ifdef _DEBUG_TTYFUNCS
1311 printk(KERN_DEBUG
"capinc_tty_hangup\n");
1315 static int capinc_tty_break_ctl(struct tty_struct
*tty
, int state
)
1317 #ifdef _DEBUG_TTYFUNCS
1318 printk(KERN_DEBUG
"capinc_tty_break_ctl(%d)\n", state
);
1323 static void capinc_tty_flush_buffer(struct tty_struct
*tty
)
1325 #ifdef _DEBUG_TTYFUNCS
1326 printk(KERN_DEBUG
"capinc_tty_flush_buffer\n");
1330 static void capinc_tty_set_ldisc(struct tty_struct
*tty
)
1332 #ifdef _DEBUG_TTYFUNCS
1333 printk(KERN_DEBUG
"capinc_tty_set_ldisc\n");
1337 static void capinc_tty_send_xchar(struct tty_struct
*tty
, char ch
)
1339 #ifdef _DEBUG_TTYFUNCS
1340 printk(KERN_DEBUG
"capinc_tty_send_xchar(%d)\n", ch
);
1344 static struct tty_driver
*capinc_tty_driver
;
1346 static const struct tty_operations capinc_ops
= {
1347 .open
= capinc_tty_open
,
1348 .close
= capinc_tty_close
,
1349 .write
= capinc_tty_write
,
1350 .put_char
= capinc_tty_put_char
,
1351 .flush_chars
= capinc_tty_flush_chars
,
1352 .write_room
= capinc_tty_write_room
,
1353 .chars_in_buffer
= capinc_tty_chars_in_buffer
,
1354 .ioctl
= capinc_tty_ioctl
,
1355 .set_termios
= capinc_tty_set_termios
,
1356 .throttle
= capinc_tty_throttle
,
1357 .unthrottle
= capinc_tty_unthrottle
,
1358 .stop
= capinc_tty_stop
,
1359 .start
= capinc_tty_start
,
1360 .hangup
= capinc_tty_hangup
,
1361 .break_ctl
= capinc_tty_break_ctl
,
1362 .flush_buffer
= capinc_tty_flush_buffer
,
1363 .set_ldisc
= capinc_tty_set_ldisc
,
1364 .send_xchar
= capinc_tty_send_xchar
,
1367 static int capinc_tty_init(void)
1369 struct tty_driver
*drv
;
1371 if (capi_ttyminors
> CAPINC_MAX_PORTS
)
1372 capi_ttyminors
= CAPINC_MAX_PORTS
;
1373 if (capi_ttyminors
<= 0)
1374 capi_ttyminors
= CAPINC_NR_PORTS
;
1376 drv
= alloc_tty_driver(capi_ttyminors
);
1380 drv
->owner
= THIS_MODULE
;
1381 drv
->driver_name
= "capi_nc";
1383 drv
->major
= capi_ttymajor
;
1384 drv
->minor_start
= 0;
1385 drv
->type
= TTY_DRIVER_TYPE_SERIAL
;
1386 drv
->subtype
= SERIAL_TYPE_NORMAL
;
1387 drv
->init_termios
= tty_std_termios
;
1388 drv
->init_termios
.c_iflag
= ICRNL
;
1389 drv
->init_termios
.c_oflag
= OPOST
| ONLCR
;
1390 drv
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1391 drv
->init_termios
.c_lflag
= 0;
1392 drv
->flags
= TTY_DRIVER_REAL_RAW
|TTY_DRIVER_RESET_TERMIOS
;
1393 tty_set_operations(drv
, &capinc_ops
);
1394 if (tty_register_driver(drv
)) {
1395 put_tty_driver(drv
);
1396 printk(KERN_ERR
"Couldn't register capi_nc driver\n");
1399 capinc_tty_driver
= drv
;
1403 static void capinc_tty_exit(void)
1405 struct tty_driver
*drv
= capinc_tty_driver
;
1407 if ((retval
= tty_unregister_driver(drv
)))
1408 printk(KERN_ERR
"capi: failed to unregister capi_nc driver (%d)\n", retval
);
1409 put_tty_driver(drv
);
1412 #else /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
1414 static inline int capinc_tty_init(void)
1419 static inline void capinc_tty_exit(void) { }
1421 #endif /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
1423 /* -------- /proc functions ----------------------------------------- */
1426 * /proc/capi/capi20:
1427 * minor applid nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt
1429 static int capi20_proc_show(struct seq_file
*m
, void *v
)
1431 struct capidev
*cdev
;
1432 struct list_head
*l
;
1434 mutex_lock(&capidev_list_lock
);
1435 list_for_each(l
, &capidev_list
) {
1436 cdev
= list_entry(l
, struct capidev
, list
);
1437 seq_printf(m
, "0 %d %lu %lu %lu %lu\n",
1439 cdev
->ap
.nrecvctlpkt
,
1440 cdev
->ap
.nrecvdatapkt
,
1441 cdev
->ap
.nsentctlpkt
,
1442 cdev
->ap
.nsentdatapkt
);
1444 mutex_unlock(&capidev_list_lock
);
1448 static int capi20_proc_open(struct inode
*inode
, struct file
*file
)
1450 return single_open(file
, capi20_proc_show
, NULL
);
1453 static const struct file_operations capi20_proc_fops
= {
1454 .owner
= THIS_MODULE
,
1455 .open
= capi20_proc_open
,
1457 .llseek
= seq_lseek
,
1458 .release
= single_release
,
1462 * /proc/capi/capi20ncci:
1465 static int capi20ncci_proc_show(struct seq_file
*m
, void *v
)
1467 struct capidev
*cdev
;
1468 struct capincci
*np
;
1469 struct list_head
*l
;
1471 mutex_lock(&capidev_list_lock
);
1472 list_for_each(l
, &capidev_list
) {
1473 cdev
= list_entry(l
, struct capidev
, list
);
1474 for (np
=cdev
->nccis
; np
; np
= np
->next
) {
1475 seq_printf(m
, "%d 0x%x\n",
1480 mutex_unlock(&capidev_list_lock
);
1484 static int capi20ncci_proc_open(struct inode
*inode
, struct file
*file
)
1486 return single_open(file
, capi20ncci_proc_show
, NULL
);
1489 static const struct file_operations capi20ncci_proc_fops
= {
1490 .owner
= THIS_MODULE
,
1491 .open
= capi20ncci_proc_open
,
1493 .llseek
= seq_lseek
,
1494 .release
= single_release
,
1497 static void __init
proc_init(void)
1499 proc_create("capi/capi20", 0, NULL
, &capi20_proc_fops
);
1500 proc_create("capi/capi20ncci", 0, NULL
, &capi20ncci_proc_fops
);
1503 static void __exit
proc_exit(void)
1505 remove_proc_entry("capi/capi20", NULL
);
1506 remove_proc_entry("capi/capi20ncci", NULL
);
1509 /* -------- init function and module interface ---------------------- */
1512 static int __init
capi_init(void)
1514 const char *compileinfo
;
1517 major_ret
= register_chrdev(capi_major
, "capi20", &capi_fops
);
1518 if (major_ret
< 0) {
1519 printk(KERN_ERR
"capi20: unable to get major %d\n", capi_major
);
1522 capi_class
= class_create(THIS_MODULE
, "capi");
1523 if (IS_ERR(capi_class
)) {
1524 unregister_chrdev(capi_major
, "capi20");
1525 return PTR_ERR(capi_class
);
1528 device_create(capi_class
, NULL
, MKDEV(capi_major
, 0), NULL
, "capi");
1530 if (capinc_tty_init() < 0) {
1531 device_destroy(capi_class
, MKDEV(capi_major
, 0));
1532 class_destroy(capi_class
);
1533 unregister_chrdev(capi_major
, "capi20");
1539 #if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
1540 compileinfo
= " (middleware+capifs)";
1541 #elif defined(CONFIG_ISDN_CAPI_MIDDLEWARE)
1542 compileinfo
= " (no capifs)";
1544 compileinfo
= " (no middleware)";
1546 printk(KERN_NOTICE
"CAPI 2.0 started up with major %d%s\n",
1547 capi_major
, compileinfo
);
1552 static void __exit
capi_exit(void)
1556 device_destroy(capi_class
, MKDEV(capi_major
, 0));
1557 class_destroy(capi_class
);
1558 unregister_chrdev(capi_major
, "capi20");
1563 module_init(capi_init
);
1564 module_exit(capi_exit
);