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_TTYFUNCS /* call to tty_driver */
49 #undef _DEBUG_DATAFLOW /* data flow */
51 /* -------- driver information -------------------------------------- */
53 static struct class *capi_class
;
54 static int capi_major
= 68; /* allocated */
56 module_param_named(major
, capi_major
, uint
, 0);
58 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
59 #define CAPINC_NR_PORTS 32
60 #define CAPINC_MAX_PORTS 256
62 static int capi_ttyminors
= CAPINC_NR_PORTS
;
64 module_param_named(ttyminors
, capi_ttyminors
, uint
, 0);
65 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
67 /* -------- defines ------------------------------------------------- */
69 #define CAPINC_MAX_RECVQUEUE 10
70 #define CAPINC_MAX_SENDQUEUE 10
71 #define CAPI_MAX_BLKSIZE 2048
73 /* -------- data structures ----------------------------------------- */
79 struct datahandle_queue
{
80 struct list_head list
;
88 struct dentry
*capifs_dentry
;
90 struct capi20_appl
*ap
;
98 struct sk_buff
*ttyskb
;
100 struct sk_buff_head inqueue
;
102 struct sk_buff_head outqueue
;
106 struct list_head ackqueue
;
111 /* FIXME: The following lock is a sledgehammer-workaround to a
112 * locking issue with the capiminor (and maybe other) data structure(s).
113 * Access to this data is done in a racy way and crashes the machine with
114 * a FritzCard DSL driver; sooner or later. This is a workaround
115 * which trades scalability vs stability, so it doesn't crash the kernel anymore.
116 * The correct (and scalable) fix for the issue seems to require
117 * an API change to the drivers... . */
118 static DEFINE_SPINLOCK(workaround_lock
);
121 struct list_head list
;
123 struct capidev
*cdev
;
124 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
125 struct capiminor
*minorp
;
126 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
130 struct list_head list
;
131 struct capi20_appl ap
;
135 struct sk_buff_head recvqueue
;
136 wait_queue_head_t recvwait
;
138 struct list_head nccis
;
143 /* -------- global variables ---------------------------------------- */
145 static DEFINE_MUTEX(capidev_list_lock
);
146 static LIST_HEAD(capidev_list
);
148 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
150 static DEFINE_SPINLOCK(capiminors_lock
);
151 static struct capiminor
**capiminors
;
153 static struct tty_driver
*capinc_tty_driver
;
155 /* -------- datahandles --------------------------------------------- */
157 static int capiminor_add_ack(struct capiminor
*mp
, u16 datahandle
)
159 struct datahandle_queue
*n
;
162 n
= kmalloc(sizeof(*n
), GFP_ATOMIC
);
164 printk(KERN_ERR
"capi: alloc datahandle failed\n");
167 n
->datahandle
= datahandle
;
168 INIT_LIST_HEAD(&n
->list
);
169 spin_lock_irqsave(&mp
->ackqlock
, flags
);
170 list_add_tail(&n
->list
, &mp
->ackqueue
);
172 spin_unlock_irqrestore(&mp
->ackqlock
, flags
);
176 static int capiminor_del_ack(struct capiminor
*mp
, u16 datahandle
)
178 struct datahandle_queue
*p
, *tmp
;
181 spin_lock_irqsave(&mp
->ackqlock
, flags
);
182 list_for_each_entry_safe(p
, tmp
, &mp
->ackqueue
, list
) {
183 if (p
->datahandle
== datahandle
) {
187 spin_unlock_irqrestore(&mp
->ackqlock
, flags
);
191 spin_unlock_irqrestore(&mp
->ackqlock
, flags
);
195 static void capiminor_del_all_ack(struct capiminor
*mp
)
197 struct datahandle_queue
*p
, *tmp
;
200 spin_lock_irqsave(&mp
->ackqlock
, flags
);
201 list_for_each_entry_safe(p
, tmp
, &mp
->ackqueue
, list
) {
206 spin_unlock_irqrestore(&mp
->ackqlock
, flags
);
210 /* -------- struct capiminor ---------------------------------------- */
212 static const struct tty_port_operations capiminor_port_ops
; /* we have none */
214 static struct capiminor
*capiminor_alloc(struct capi20_appl
*ap
, u32 ncci
)
216 struct capiminor
*mp
;
220 mp
= kzalloc(sizeof(*mp
), GFP_KERNEL
);
222 printk(KERN_ERR
"capi: can't alloc capiminor\n");
226 kref_init(&mp
->kref
);
231 INIT_LIST_HEAD(&mp
->ackqueue
);
232 spin_lock_init(&mp
->ackqlock
);
234 skb_queue_head_init(&mp
->inqueue
);
235 skb_queue_head_init(&mp
->outqueue
);
237 tty_port_init(&mp
->port
);
238 mp
->port
.ops
= &capiminor_port_ops
;
240 /* Allocate the least unused minor number. */
241 spin_lock(&capiminors_lock
);
242 for (minor
= 0; minor
< capi_ttyminors
; minor
++)
243 if (!capiminors
[minor
]) {
244 capiminors
[minor
] = mp
;
247 spin_unlock(&capiminors_lock
);
249 if (minor
== capi_ttyminors
) {
250 printk(KERN_NOTICE
"capi: out of minors\n");
256 dev
= tty_register_device(capinc_tty_driver
, minor
, NULL
);
263 spin_lock(&capiminors_lock
);
264 capiminors
[minor
] = NULL
;
265 spin_unlock(&capiminors_lock
);
272 static void capiminor_destroy(struct kref
*kref
)
274 struct capiminor
*mp
= container_of(kref
, struct capiminor
, kref
);
276 kfree_skb(mp
->ttyskb
);
277 skb_queue_purge(&mp
->inqueue
);
278 skb_queue_purge(&mp
->outqueue
);
279 capiminor_del_all_ack(mp
);
283 static struct capiminor
*capiminor_get(unsigned int minor
)
285 struct capiminor
*mp
;
287 spin_lock(&capiminors_lock
);
288 mp
= capiminors
[minor
];
291 spin_unlock(&capiminors_lock
);
296 static inline void capiminor_put(struct capiminor
*mp
)
298 kref_put(&mp
->kref
, capiminor_destroy
);
301 static void capiminor_free(struct capiminor
*mp
)
303 tty_unregister_device(capinc_tty_driver
, mp
->minor
);
305 spin_lock(&capiminors_lock
);
306 capiminors
[mp
->minor
] = NULL
;
307 spin_unlock(&capiminors_lock
);
312 /* -------- struct capincci ----------------------------------------- */
314 static void capincci_alloc_minor(struct capidev
*cdev
, struct capincci
*np
)
316 struct capiminor
*mp
;
319 if (!(cdev
->userflags
& CAPIFLAG_HIGHJACKING
))
322 mp
= np
->minorp
= capiminor_alloc(&cdev
->ap
, np
->ncci
);
324 device
= MKDEV(capinc_tty_driver
->major
, mp
->minor
);
325 mp
->capifs_dentry
= capifs_new_ncci(mp
->minor
, device
);
329 static void capincci_free_minor(struct capincci
*np
)
331 struct capiminor
*mp
= np
->minorp
;
332 struct tty_struct
*tty
;
335 capifs_free_ncci(mp
->capifs_dentry
);
337 tty
= tty_port_tty_get(&mp
->port
);
347 static inline unsigned int capincci_minor_opencount(struct capincci
*np
)
349 struct capiminor
*mp
= np
->minorp
;
350 unsigned int count
= 0;
351 struct tty_struct
*tty
;
354 tty
= tty_port_tty_get(&mp
->port
);
363 #else /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
366 capincci_alloc_minor(struct capidev
*cdev
, struct capincci
*np
) { }
367 static inline void capincci_free_minor(struct capincci
*np
) { }
369 static inline unsigned int capincci_minor_opencount(struct capincci
*np
)
374 #endif /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
376 static struct capincci
*capincci_alloc(struct capidev
*cdev
, u32 ncci
)
380 np
= kzalloc(sizeof(*np
), GFP_KERNEL
);
386 capincci_alloc_minor(cdev
, np
);
388 list_add_tail(&np
->list
, &cdev
->nccis
);
393 static void capincci_free(struct capidev
*cdev
, u32 ncci
)
395 struct capincci
*np
, *tmp
;
397 list_for_each_entry_safe(np
, tmp
, &cdev
->nccis
, list
)
398 if (ncci
== 0xffffffff || np
->ncci
== ncci
) {
399 capincci_free_minor(np
);
405 static struct capincci
*capincci_find(struct capidev
*cdev
, u32 ncci
)
409 list_for_each_entry(np
, &cdev
->nccis
, list
)
410 if (np
->ncci
== ncci
)
415 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
416 /* -------- handle data queue --------------------------------------- */
418 static struct sk_buff
*
419 gen_data_b3_resp_for(struct capiminor
*mp
, struct sk_buff
*skb
)
421 struct sk_buff
*nskb
;
422 nskb
= alloc_skb(CAPI_DATA_B3_RESP_LEN
, GFP_ATOMIC
);
424 u16 datahandle
= CAPIMSG_U16(skb
->data
,CAPIMSG_BASELEN
+4+4+2);
425 unsigned char *s
= skb_put(nskb
, CAPI_DATA_B3_RESP_LEN
);
426 capimsg_setu16(s
, 0, CAPI_DATA_B3_RESP_LEN
);
427 capimsg_setu16(s
, 2, mp
->ap
->applid
);
428 capimsg_setu8 (s
, 4, CAPI_DATA_B3
);
429 capimsg_setu8 (s
, 5, CAPI_RESP
);
430 capimsg_setu16(s
, 6, mp
->msgid
++);
431 capimsg_setu32(s
, 8, mp
->ncci
);
432 capimsg_setu16(s
, 12, datahandle
);
437 static int handle_recv_skb(struct capiminor
*mp
, struct sk_buff
*skb
)
439 struct tty_struct
*tty
;
440 struct sk_buff
*nskb
;
442 u16 errcode
, datahandle
;
443 struct tty_ldisc
*ld
;
446 datalen
= skb
->len
- CAPIMSG_LEN(skb
->data
);
448 tty
= tty_port_tty_get(&mp
->port
);
450 #ifdef _DEBUG_DATAFLOW
451 printk(KERN_DEBUG
"capi: currently no receiver\n");
456 ld
= tty_ldisc_ref(tty
);
460 if (ld
->ops
->receive_buf
== NULL
) {
461 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
462 printk(KERN_DEBUG
"capi: ldisc has no receive_buf function\n");
467 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
468 printk(KERN_DEBUG
"capi: recv tty throttled\n");
472 if (tty
->receive_room
< datalen
) {
473 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
474 printk(KERN_DEBUG
"capi: no room in tty\n");
478 if ((nskb
= gen_data_b3_resp_for(mp
, skb
)) == NULL
) {
479 printk(KERN_ERR
"capi: gen_data_b3_resp failed\n");
482 datahandle
= CAPIMSG_U16(skb
->data
,CAPIMSG_BASELEN
+4);
483 errcode
= capi20_put_message(mp
->ap
, nskb
);
484 if (errcode
!= CAPI_NOERROR
) {
485 printk(KERN_ERR
"capi: send DATA_B3_RESP failed=%x\n",
490 (void)skb_pull(skb
, CAPIMSG_LEN(skb
->data
));
491 #ifdef _DEBUG_DATAFLOW
492 printk(KERN_DEBUG
"capi: DATA_B3_RESP %u len=%d => ldisc\n",
493 datahandle
, skb
->len
);
495 ld
->ops
->receive_buf(tty
, skb
->data
, NULL
, skb
->len
);
505 static void handle_minor_recv(struct capiminor
*mp
)
508 while ((skb
= skb_dequeue(&mp
->inqueue
)) != NULL
) {
509 unsigned int len
= skb
->len
;
511 if (handle_recv_skb(mp
, skb
) < 0) {
512 skb_queue_head(&mp
->inqueue
, skb
);
519 static int handle_minor_send(struct capiminor
*mp
)
521 struct tty_struct
*tty
;
528 tty
= tty_port_tty_get(&mp
->port
);
532 if (mp
->ttyoutstop
) {
533 #if defined(_DEBUG_DATAFLOW) || defined(_DEBUG_TTYFUNCS)
534 printk(KERN_DEBUG
"capi: send: tty stopped\n");
540 while ((skb
= skb_dequeue(&mp
->outqueue
)) != NULL
) {
541 datahandle
= mp
->datahandle
;
543 skb_push(skb
, CAPI_DATA_B3_REQ_LEN
);
544 memset(skb
->data
, 0, CAPI_DATA_B3_REQ_LEN
);
545 capimsg_setu16(skb
->data
, 0, CAPI_DATA_B3_REQ_LEN
);
546 capimsg_setu16(skb
->data
, 2, mp
->ap
->applid
);
547 capimsg_setu8 (skb
->data
, 4, CAPI_DATA_B3
);
548 capimsg_setu8 (skb
->data
, 5, CAPI_REQ
);
549 capimsg_setu16(skb
->data
, 6, mp
->msgid
++);
550 capimsg_setu32(skb
->data
, 8, mp
->ncci
); /* NCCI */
551 capimsg_setu32(skb
->data
, 12, (u32
)(long)skb
->data
);/* Data32 */
552 capimsg_setu16(skb
->data
, 16, len
); /* Data length */
553 capimsg_setu16(skb
->data
, 18, datahandle
);
554 capimsg_setu16(skb
->data
, 20, 0); /* Flags */
556 if (capiminor_add_ack(mp
, datahandle
) < 0) {
557 skb_pull(skb
, CAPI_DATA_B3_REQ_LEN
);
558 skb_queue_head(&mp
->outqueue
, skb
);
562 errcode
= capi20_put_message(mp
->ap
, skb
);
563 if (errcode
== CAPI_NOERROR
) {
567 #ifdef _DEBUG_DATAFLOW
568 printk(KERN_DEBUG
"capi: DATA_B3_REQ %u len=%u\n",
573 capiminor_del_ack(mp
, datahandle
);
575 if (errcode
== CAPI_SENDQUEUEFULL
) {
576 skb_pull(skb
, CAPI_DATA_B3_REQ_LEN
);
577 skb_queue_head(&mp
->outqueue
, skb
);
581 /* ups, drop packet */
582 printk(KERN_ERR
"capi: put_message = %x\n", errcode
);
590 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
591 /* -------- function called by lower level -------------------------- */
593 static void capi_recv_message(struct capi20_appl
*ap
, struct sk_buff
*skb
)
595 struct capidev
*cdev
= ap
->private;
596 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
597 struct tty_struct
*tty
;
598 struct capiminor
*mp
;
600 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
604 mutex_lock(&cdev
->lock
);
606 if (CAPIMSG_CMD(skb
->data
) == CAPI_CONNECT_B3_CONF
) {
607 u16 info
= CAPIMSG_U16(skb
->data
, 12); // Info field
608 if ((info
& 0xff00) == 0)
609 capincci_alloc(cdev
, CAPIMSG_NCCI(skb
->data
));
611 if (CAPIMSG_CMD(skb
->data
) == CAPI_CONNECT_B3_IND
)
612 capincci_alloc(cdev
, CAPIMSG_NCCI(skb
->data
));
614 spin_lock_irqsave(&workaround_lock
, flags
);
615 if (CAPIMSG_COMMAND(skb
->data
) != CAPI_DATA_B3
) {
616 skb_queue_tail(&cdev
->recvqueue
, skb
);
617 wake_up_interruptible(&cdev
->recvwait
);
621 np
= capincci_find(cdev
, CAPIMSG_CONTROL(skb
->data
));
623 printk(KERN_ERR
"BUG: capi_signal: ncci not found\n");
624 skb_queue_tail(&cdev
->recvqueue
, skb
);
625 wake_up_interruptible(&cdev
->recvwait
);
629 #ifndef CONFIG_ISDN_CAPI_MIDDLEWARE
630 skb_queue_tail(&cdev
->recvqueue
, skb
);
631 wake_up_interruptible(&cdev
->recvwait
);
633 #else /* CONFIG_ISDN_CAPI_MIDDLEWARE */
637 skb_queue_tail(&cdev
->recvqueue
, skb
);
638 wake_up_interruptible(&cdev
->recvwait
);
641 if (CAPIMSG_SUBCOMMAND(skb
->data
) == CAPI_IND
) {
642 datahandle
= CAPIMSG_U16(skb
->data
, CAPIMSG_BASELEN
+4+4+2);
643 #ifdef _DEBUG_DATAFLOW
644 printk(KERN_DEBUG
"capi_signal: DATA_B3_IND %u len=%d\n",
645 datahandle
, skb
->len
-CAPIMSG_LEN(skb
->data
));
647 skb_queue_tail(&mp
->inqueue
, skb
);
648 mp
->inbytes
+= skb
->len
;
649 handle_minor_recv(mp
);
651 } else if (CAPIMSG_SUBCOMMAND(skb
->data
) == CAPI_CONF
) {
653 datahandle
= CAPIMSG_U16(skb
->data
, CAPIMSG_BASELEN
+4);
654 #ifdef _DEBUG_DATAFLOW
655 printk(KERN_DEBUG
"capi_signal: DATA_B3_CONF %u 0x%x\n",
657 CAPIMSG_U16(skb
->data
, CAPIMSG_BASELEN
+4+2));
660 (void)capiminor_del_ack(mp
, datahandle
);
661 tty
= tty_port_tty_get(&mp
->port
);
666 (void)handle_minor_send(mp
);
669 /* ups, let capi application handle it :-) */
670 skb_queue_tail(&cdev
->recvqueue
, skb
);
671 wake_up_interruptible(&cdev
->recvwait
);
673 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
676 spin_unlock_irqrestore(&workaround_lock
, flags
);
677 mutex_unlock(&cdev
->lock
);
680 /* -------- file_operations for capidev ----------------------------- */
683 capi_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
685 struct capidev
*cdev
= (struct capidev
*)file
->private_data
;
690 if (!cdev
->ap
.applid
)
693 skb
= skb_dequeue(&cdev
->recvqueue
);
695 if (file
->f_flags
& O_NONBLOCK
)
697 err
= wait_event_interruptible(cdev
->recvwait
,
698 (skb
= skb_dequeue(&cdev
->recvqueue
)));
702 if (skb
->len
> count
) {
703 skb_queue_head(&cdev
->recvqueue
, skb
);
706 if (copy_to_user(buf
, skb
->data
, skb
->len
)) {
707 skb_queue_head(&cdev
->recvqueue
, skb
);
718 capi_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
720 struct capidev
*cdev
= (struct capidev
*)file
->private_data
;
724 if (!cdev
->ap
.applid
)
727 skb
= alloc_skb(count
, GFP_USER
);
731 if (copy_from_user(skb_put(skb
, count
), buf
, count
)) {
735 mlen
= CAPIMSG_LEN(skb
->data
);
736 if (CAPIMSG_CMD(skb
->data
) == CAPI_DATA_B3_REQ
) {
737 if ((size_t)(mlen
+ CAPIMSG_DATALEN(skb
->data
)) != count
) {
747 CAPIMSG_SETAPPID(skb
->data
, cdev
->ap
.applid
);
749 if (CAPIMSG_CMD(skb
->data
) == CAPI_DISCONNECT_B3_RESP
) {
750 mutex_lock(&cdev
->lock
);
751 capincci_free(cdev
, CAPIMSG_NCCI(skb
->data
));
752 mutex_unlock(&cdev
->lock
);
755 cdev
->errcode
= capi20_put_message(&cdev
->ap
, skb
);
765 capi_poll(struct file
*file
, poll_table
* wait
)
767 struct capidev
*cdev
= (struct capidev
*)file
->private_data
;
768 unsigned int mask
= 0;
770 if (!cdev
->ap
.applid
)
773 poll_wait(file
, &(cdev
->recvwait
), wait
);
774 mask
= POLLOUT
| POLLWRNORM
;
775 if (!skb_queue_empty(&cdev
->recvqueue
))
776 mask
|= POLLIN
| POLLRDNORM
;
781 capi_ioctl(struct inode
*inode
, struct file
*file
,
782 unsigned int cmd
, unsigned long arg
)
784 struct capidev
*cdev
= file
->private_data
;
785 capi_ioctl_struct data
;
786 int retval
= -EINVAL
;
787 void __user
*argp
= (void __user
*)arg
;
791 mutex_lock(&cdev
->lock
);
793 if (cdev
->ap
.applid
) {
797 if (copy_from_user(&cdev
->ap
.rparam
, argp
,
798 sizeof(struct capi_register_params
))) {
802 cdev
->ap
.private = cdev
;
803 cdev
->ap
.recv_message
= capi_recv_message
;
804 cdev
->errcode
= capi20_register(&cdev
->ap
);
805 retval
= (int)cdev
->ap
.applid
;
812 mutex_unlock(&cdev
->lock
);
815 case CAPI_GET_VERSION
:
817 if (copy_from_user(&data
.contr
, argp
,
820 cdev
->errcode
= capi20_get_version(data
.contr
, &data
.version
);
823 if (copy_to_user(argp
, &data
.version
,
824 sizeof(data
.version
)))
829 case CAPI_GET_SERIAL
:
831 if (copy_from_user(&data
.contr
, argp
,
834 cdev
->errcode
= capi20_get_serial (data
.contr
, data
.serial
);
837 if (copy_to_user(argp
, data
.serial
,
838 sizeof(data
.serial
)))
842 case CAPI_GET_PROFILE
:
844 if (copy_from_user(&data
.contr
, argp
,
848 if (data
.contr
== 0) {
849 cdev
->errcode
= capi20_get_profile(data
.contr
, &data
.profile
);
853 retval
= copy_to_user(argp
,
854 &data
.profile
.ncontroller
,
855 sizeof(data
.profile
.ncontroller
));
858 cdev
->errcode
= capi20_get_profile(data
.contr
, &data
.profile
);
862 retval
= copy_to_user(argp
, &data
.profile
,
863 sizeof(data
.profile
));
870 case CAPI_GET_MANUFACTURER
:
872 if (copy_from_user(&data
.contr
, argp
,
875 cdev
->errcode
= capi20_get_manufacturer(data
.contr
, data
.manufacturer
);
879 if (copy_to_user(argp
, data
.manufacturer
,
880 sizeof(data
.manufacturer
)))
885 case CAPI_GET_ERRCODE
:
886 data
.errcode
= cdev
->errcode
;
887 cdev
->errcode
= CAPI_NOERROR
;
889 if (copy_to_user(argp
, &data
.errcode
,
890 sizeof(data
.errcode
)))
896 if (capi20_isinstalled() == CAPI_NOERROR
)
900 case CAPI_MANUFACTURER_CMD
:
902 struct capi_manufacturer_cmd mcmd
;
903 if (!capable(CAP_SYS_ADMIN
))
905 if (copy_from_user(&mcmd
, argp
, sizeof(mcmd
)))
907 return capi20_manufacturer(mcmd
.cmd
, mcmd
.data
);
912 case CAPI_CLR_FLAGS
: {
915 if (copy_from_user(&userflags
, argp
, sizeof(userflags
)))
918 mutex_lock(&cdev
->lock
);
919 if (cmd
== CAPI_SET_FLAGS
)
920 cdev
->userflags
|= userflags
;
922 cdev
->userflags
&= ~userflags
;
923 mutex_unlock(&cdev
->lock
);
927 if (copy_to_user(argp
, &cdev
->userflags
,
928 sizeof(cdev
->userflags
)))
932 case CAPI_NCCI_OPENCOUNT
: {
933 struct capincci
*nccip
;
937 if (copy_from_user(&ncci
, argp
, sizeof(ncci
)))
940 mutex_lock(&cdev
->lock
);
941 nccip
= capincci_find(cdev
, (u32
)ncci
);
943 count
= capincci_minor_opencount(nccip
);
944 mutex_unlock(&cdev
->lock
);
948 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
949 case CAPI_NCCI_GETUNIT
: {
950 struct capincci
*nccip
;
951 struct capiminor
*mp
;
955 if (copy_from_user(&ncci
, argp
, sizeof(ncci
)))
958 mutex_lock(&cdev
->lock
);
959 nccip
= capincci_find(cdev
, (u32
)ncci
);
965 mutex_unlock(&cdev
->lock
);
968 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
975 static int capi_open(struct inode
*inode
, struct file
*file
)
977 struct capidev
*cdev
;
979 cdev
= kzalloc(sizeof(*cdev
), GFP_KERNEL
);
983 mutex_init(&cdev
->lock
);
984 skb_queue_head_init(&cdev
->recvqueue
);
985 init_waitqueue_head(&cdev
->recvwait
);
986 INIT_LIST_HEAD(&cdev
->nccis
);
987 file
->private_data
= cdev
;
989 mutex_lock(&capidev_list_lock
);
990 list_add_tail(&cdev
->list
, &capidev_list
);
991 mutex_unlock(&capidev_list_lock
);
993 return nonseekable_open(inode
, file
);
996 static int capi_release(struct inode
*inode
, struct file
*file
)
998 struct capidev
*cdev
= file
->private_data
;
1000 mutex_lock(&capidev_list_lock
);
1001 list_del(&cdev
->list
);
1002 mutex_unlock(&capidev_list_lock
);
1004 if (cdev
->ap
.applid
)
1005 capi20_release(&cdev
->ap
);
1006 skb_queue_purge(&cdev
->recvqueue
);
1007 capincci_free(cdev
, 0xffffffff);
1013 static const struct file_operations capi_fops
=
1015 .owner
= THIS_MODULE
,
1016 .llseek
= no_llseek
,
1018 .write
= capi_write
,
1020 .ioctl
= capi_ioctl
,
1022 .release
= capi_release
,
1025 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
1026 /* -------- tty_operations for capincci ----------------------------- */
1029 capinc_tty_install(struct tty_driver
*driver
, struct tty_struct
*tty
)
1031 int idx
= tty
->index
;
1032 struct capiminor
*mp
= capiminor_get(idx
);
1033 int ret
= tty_init_termios(tty
);
1036 tty_driver_kref_get(driver
);
1038 tty
->driver_data
= mp
;
1039 driver
->ttys
[idx
] = tty
;
1045 static void capinc_tty_cleanup(struct tty_struct
*tty
)
1047 struct capiminor
*mp
= tty
->driver_data
;
1048 tty
->driver_data
= NULL
;
1052 static int capinc_tty_open(struct tty_struct
*tty
, struct file
*filp
)
1054 struct capiminor
*mp
= tty
->driver_data
;
1055 unsigned long flags
;
1058 err
= tty_port_open(&mp
->port
, tty
, filp
);
1062 spin_lock_irqsave(&workaround_lock
, flags
);
1063 handle_minor_recv(mp
);
1064 spin_unlock_irqrestore(&workaround_lock
, flags
);
1068 static void capinc_tty_close(struct tty_struct
*tty
, struct file
*filp
)
1070 struct capiminor
*mp
= tty
->driver_data
;
1072 tty_port_close(&mp
->port
, tty
, filp
);
1075 static int capinc_tty_write(struct tty_struct
*tty
,
1076 const unsigned char *buf
, int count
)
1078 struct capiminor
*mp
= tty
->driver_data
;
1079 struct sk_buff
*skb
;
1080 unsigned long flags
;
1082 #ifdef _DEBUG_TTYFUNCS
1083 printk(KERN_DEBUG
"capinc_tty_write(count=%d)\n", count
);
1086 spin_lock_irqsave(&workaround_lock
, flags
);
1090 skb_queue_tail(&mp
->outqueue
, skb
);
1091 mp
->outbytes
+= skb
->len
;
1094 skb
= alloc_skb(CAPI_DATA_B3_REQ_LEN
+count
, GFP_ATOMIC
);
1096 printk(KERN_ERR
"capinc_tty_write: alloc_skb failed\n");
1097 spin_unlock_irqrestore(&workaround_lock
, flags
);
1101 skb_reserve(skb
, CAPI_DATA_B3_REQ_LEN
);
1102 memcpy(skb_put(skb
, count
), buf
, count
);
1104 skb_queue_tail(&mp
->outqueue
, skb
);
1105 mp
->outbytes
+= skb
->len
;
1106 (void)handle_minor_send(mp
);
1107 spin_unlock_irqrestore(&workaround_lock
, flags
);
1111 static int capinc_tty_put_char(struct tty_struct
*tty
, unsigned char ch
)
1113 struct capiminor
*mp
= tty
->driver_data
;
1114 struct sk_buff
*skb
;
1115 unsigned long flags
;
1118 #ifdef _DEBUG_TTYFUNCS
1119 printk(KERN_DEBUG
"capinc_put_char(%u)\n", ch
);
1122 spin_lock_irqsave(&workaround_lock
, flags
);
1125 if (skb_tailroom(skb
) > 0) {
1126 *(skb_put(skb
, 1)) = ch
;
1127 spin_unlock_irqrestore(&workaround_lock
, flags
);
1131 skb_queue_tail(&mp
->outqueue
, skb
);
1132 mp
->outbytes
+= skb
->len
;
1133 (void)handle_minor_send(mp
);
1135 skb
= alloc_skb(CAPI_DATA_B3_REQ_LEN
+CAPI_MAX_BLKSIZE
, GFP_ATOMIC
);
1137 skb_reserve(skb
, CAPI_DATA_B3_REQ_LEN
);
1138 *(skb_put(skb
, 1)) = ch
;
1141 printk(KERN_ERR
"capinc_put_char: char %u lost\n", ch
);
1144 spin_unlock_irqrestore(&workaround_lock
, flags
);
1148 static void capinc_tty_flush_chars(struct tty_struct
*tty
)
1150 struct capiminor
*mp
= tty
->driver_data
;
1151 struct sk_buff
*skb
;
1152 unsigned long flags
;
1154 #ifdef _DEBUG_TTYFUNCS
1155 printk(KERN_DEBUG
"capinc_tty_flush_chars\n");
1158 spin_lock_irqsave(&workaround_lock
, flags
);
1162 skb_queue_tail(&mp
->outqueue
, skb
);
1163 mp
->outbytes
+= skb
->len
;
1164 (void)handle_minor_send(mp
);
1166 (void)handle_minor_recv(mp
);
1167 spin_unlock_irqrestore(&workaround_lock
, flags
);
1170 static int capinc_tty_write_room(struct tty_struct
*tty
)
1172 struct capiminor
*mp
= tty
->driver_data
;
1175 room
= CAPINC_MAX_SENDQUEUE
-skb_queue_len(&mp
->outqueue
);
1176 room
*= CAPI_MAX_BLKSIZE
;
1177 #ifdef _DEBUG_TTYFUNCS
1178 printk(KERN_DEBUG
"capinc_tty_write_room = %d\n", room
);
1183 static int capinc_tty_chars_in_buffer(struct tty_struct
*tty
)
1185 struct capiminor
*mp
= tty
->driver_data
;
1187 #ifdef _DEBUG_TTYFUNCS
1188 printk(KERN_DEBUG
"capinc_tty_chars_in_buffer = %d nack=%d sq=%d rq=%d\n",
1189 mp
->outbytes
, mp
->nack
,
1190 skb_queue_len(&mp
->outqueue
),
1191 skb_queue_len(&mp
->inqueue
));
1193 return mp
->outbytes
;
1196 static int capinc_tty_ioctl(struct tty_struct
*tty
, struct file
* file
,
1197 unsigned int cmd
, unsigned long arg
)
1202 error
= n_tty_ioctl_helper(tty
, file
, cmd
, arg
);
1208 static void capinc_tty_set_termios(struct tty_struct
*tty
, struct ktermios
* old
)
1210 #ifdef _DEBUG_TTYFUNCS
1211 printk(KERN_DEBUG
"capinc_tty_set_termios\n");
1215 static void capinc_tty_throttle(struct tty_struct
*tty
)
1217 struct capiminor
*mp
= tty
->driver_data
;
1218 #ifdef _DEBUG_TTYFUNCS
1219 printk(KERN_DEBUG
"capinc_tty_throttle\n");
1224 static void capinc_tty_unthrottle(struct tty_struct
*tty
)
1226 struct capiminor
*mp
= tty
->driver_data
;
1227 unsigned long flags
;
1229 #ifdef _DEBUG_TTYFUNCS
1230 printk(KERN_DEBUG
"capinc_tty_unthrottle\n");
1232 spin_lock_irqsave(&workaround_lock
, flags
);
1234 handle_minor_recv(mp
);
1235 spin_unlock_irqrestore(&workaround_lock
, flags
);
1238 static void capinc_tty_stop(struct tty_struct
*tty
)
1240 struct capiminor
*mp
= tty
->driver_data
;
1242 #ifdef _DEBUG_TTYFUNCS
1243 printk(KERN_DEBUG
"capinc_tty_stop\n");
1248 static void capinc_tty_start(struct tty_struct
*tty
)
1250 struct capiminor
*mp
= tty
->driver_data
;
1251 unsigned long flags
;
1253 #ifdef _DEBUG_TTYFUNCS
1254 printk(KERN_DEBUG
"capinc_tty_start\n");
1256 spin_lock_irqsave(&workaround_lock
, flags
);
1258 (void)handle_minor_send(mp
);
1259 spin_unlock_irqrestore(&workaround_lock
, flags
);
1262 static void capinc_tty_hangup(struct tty_struct
*tty
)
1264 struct capiminor
*mp
= tty
->driver_data
;
1266 #ifdef _DEBUG_TTYFUNCS
1267 printk(KERN_DEBUG
"capinc_tty_hangup\n");
1269 tty_port_hangup(&mp
->port
);
1272 static int capinc_tty_break_ctl(struct tty_struct
*tty
, int state
)
1274 #ifdef _DEBUG_TTYFUNCS
1275 printk(KERN_DEBUG
"capinc_tty_break_ctl(%d)\n", state
);
1280 static void capinc_tty_flush_buffer(struct tty_struct
*tty
)
1282 #ifdef _DEBUG_TTYFUNCS
1283 printk(KERN_DEBUG
"capinc_tty_flush_buffer\n");
1287 static void capinc_tty_set_ldisc(struct tty_struct
*tty
)
1289 #ifdef _DEBUG_TTYFUNCS
1290 printk(KERN_DEBUG
"capinc_tty_set_ldisc\n");
1294 static void capinc_tty_send_xchar(struct tty_struct
*tty
, char ch
)
1296 #ifdef _DEBUG_TTYFUNCS
1297 printk(KERN_DEBUG
"capinc_tty_send_xchar(%d)\n", ch
);
1301 static const struct tty_operations capinc_ops
= {
1302 .open
= capinc_tty_open
,
1303 .close
= capinc_tty_close
,
1304 .write
= capinc_tty_write
,
1305 .put_char
= capinc_tty_put_char
,
1306 .flush_chars
= capinc_tty_flush_chars
,
1307 .write_room
= capinc_tty_write_room
,
1308 .chars_in_buffer
= capinc_tty_chars_in_buffer
,
1309 .ioctl
= capinc_tty_ioctl
,
1310 .set_termios
= capinc_tty_set_termios
,
1311 .throttle
= capinc_tty_throttle
,
1312 .unthrottle
= capinc_tty_unthrottle
,
1313 .stop
= capinc_tty_stop
,
1314 .start
= capinc_tty_start
,
1315 .hangup
= capinc_tty_hangup
,
1316 .break_ctl
= capinc_tty_break_ctl
,
1317 .flush_buffer
= capinc_tty_flush_buffer
,
1318 .set_ldisc
= capinc_tty_set_ldisc
,
1319 .send_xchar
= capinc_tty_send_xchar
,
1320 .install
= capinc_tty_install
,
1321 .cleanup
= capinc_tty_cleanup
,
1324 static int __init
capinc_tty_init(void)
1326 struct tty_driver
*drv
;
1329 if (capi_ttyminors
> CAPINC_MAX_PORTS
)
1330 capi_ttyminors
= CAPINC_MAX_PORTS
;
1331 if (capi_ttyminors
<= 0)
1332 capi_ttyminors
= CAPINC_NR_PORTS
;
1334 capiminors
= kzalloc(sizeof(struct capi_minor
*) * capi_ttyminors
,
1339 drv
= alloc_tty_driver(capi_ttyminors
);
1344 drv
->owner
= THIS_MODULE
;
1345 drv
->driver_name
= "capi_nc";
1348 drv
->minor_start
= 0;
1349 drv
->type
= TTY_DRIVER_TYPE_SERIAL
;
1350 drv
->subtype
= SERIAL_TYPE_NORMAL
;
1351 drv
->init_termios
= tty_std_termios
;
1352 drv
->init_termios
.c_iflag
= ICRNL
;
1353 drv
->init_termios
.c_oflag
= OPOST
| ONLCR
;
1354 drv
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1355 drv
->init_termios
.c_lflag
= 0;
1357 TTY_DRIVER_REAL_RAW
| TTY_DRIVER_RESET_TERMIOS
|
1358 TTY_DRIVER_DYNAMIC_DEV
;
1359 tty_set_operations(drv
, &capinc_ops
);
1361 err
= tty_register_driver(drv
);
1363 put_tty_driver(drv
);
1365 printk(KERN_ERR
"Couldn't register capi_nc driver\n");
1368 capinc_tty_driver
= drv
;
1372 static void __exit
capinc_tty_exit(void)
1374 tty_unregister_driver(capinc_tty_driver
);
1375 put_tty_driver(capinc_tty_driver
);
1379 #else /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
1381 static inline int capinc_tty_init(void)
1386 static inline void capinc_tty_exit(void) { }
1388 #endif /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
1390 /* -------- /proc functions ----------------------------------------- */
1393 * /proc/capi/capi20:
1394 * minor applid nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt
1396 static int capi20_proc_show(struct seq_file
*m
, void *v
)
1398 struct capidev
*cdev
;
1399 struct list_head
*l
;
1401 mutex_lock(&capidev_list_lock
);
1402 list_for_each(l
, &capidev_list
) {
1403 cdev
= list_entry(l
, struct capidev
, list
);
1404 seq_printf(m
, "0 %d %lu %lu %lu %lu\n",
1406 cdev
->ap
.nrecvctlpkt
,
1407 cdev
->ap
.nrecvdatapkt
,
1408 cdev
->ap
.nsentctlpkt
,
1409 cdev
->ap
.nsentdatapkt
);
1411 mutex_unlock(&capidev_list_lock
);
1415 static int capi20_proc_open(struct inode
*inode
, struct file
*file
)
1417 return single_open(file
, capi20_proc_show
, NULL
);
1420 static const struct file_operations capi20_proc_fops
= {
1421 .owner
= THIS_MODULE
,
1422 .open
= capi20_proc_open
,
1424 .llseek
= seq_lseek
,
1425 .release
= single_release
,
1429 * /proc/capi/capi20ncci:
1432 static int capi20ncci_proc_show(struct seq_file
*m
, void *v
)
1434 struct capidev
*cdev
;
1435 struct capincci
*np
;
1437 mutex_lock(&capidev_list_lock
);
1438 list_for_each_entry(cdev
, &capidev_list
, list
) {
1439 mutex_lock(&cdev
->lock
);
1440 list_for_each_entry(np
, &cdev
->nccis
, list
)
1441 seq_printf(m
, "%d 0x%x\n", cdev
->ap
.applid
, np
->ncci
);
1442 mutex_unlock(&cdev
->lock
);
1444 mutex_unlock(&capidev_list_lock
);
1448 static int capi20ncci_proc_open(struct inode
*inode
, struct file
*file
)
1450 return single_open(file
, capi20ncci_proc_show
, NULL
);
1453 static const struct file_operations capi20ncci_proc_fops
= {
1454 .owner
= THIS_MODULE
,
1455 .open
= capi20ncci_proc_open
,
1457 .llseek
= seq_lseek
,
1458 .release
= single_release
,
1461 static void __init
proc_init(void)
1463 proc_create("capi/capi20", 0, NULL
, &capi20_proc_fops
);
1464 proc_create("capi/capi20ncci", 0, NULL
, &capi20ncci_proc_fops
);
1467 static void __exit
proc_exit(void)
1469 remove_proc_entry("capi/capi20", NULL
);
1470 remove_proc_entry("capi/capi20ncci", NULL
);
1473 /* -------- init function and module interface ---------------------- */
1476 static int __init
capi_init(void)
1478 const char *compileinfo
;
1481 major_ret
= register_chrdev(capi_major
, "capi20", &capi_fops
);
1482 if (major_ret
< 0) {
1483 printk(KERN_ERR
"capi20: unable to get major %d\n", capi_major
);
1486 capi_class
= class_create(THIS_MODULE
, "capi");
1487 if (IS_ERR(capi_class
)) {
1488 unregister_chrdev(capi_major
, "capi20");
1489 return PTR_ERR(capi_class
);
1492 device_create(capi_class
, NULL
, MKDEV(capi_major
, 0), NULL
, "capi");
1494 if (capinc_tty_init() < 0) {
1495 device_destroy(capi_class
, MKDEV(capi_major
, 0));
1496 class_destroy(capi_class
);
1497 unregister_chrdev(capi_major
, "capi20");
1503 #if defined(CONFIG_ISDN_CAPI_CAPIFS) || defined(CONFIG_ISDN_CAPI_CAPIFS_MODULE)
1504 compileinfo
= " (middleware+capifs)";
1505 #elif defined(CONFIG_ISDN_CAPI_MIDDLEWARE)
1506 compileinfo
= " (no capifs)";
1508 compileinfo
= " (no middleware)";
1510 printk(KERN_NOTICE
"CAPI 2.0 started up with major %d%s\n",
1511 capi_major
, compileinfo
);
1516 static void __exit
capi_exit(void)
1520 device_destroy(capi_class
, MKDEV(capi_major
, 0));
1521 class_destroy(capi_class
);
1522 unregister_chrdev(capi_major
, "capi20");
1527 module_init(capi_init
);
1528 module_exit(capi_exit
);