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/timer.h>
24 #include <linux/wait.h>
25 #include <linux/tty.h>
26 #include <linux/netdevice.h>
27 #include <linux/ppp_defs.h>
28 #include <linux/ppp-ioctl.h>
29 #include <linux/skbuff.h>
30 #include <linux/proc_fs.h>
31 #include <linux/seq_file.h>
32 #include <linux/poll.h>
33 #include <linux/capi.h>
34 #include <linux/kernelcapi.h>
35 #include <linux/init.h>
36 #include <linux/device.h>
37 #include <linux/moduleparam.h>
38 #include <linux/isdn/capiutil.h>
39 #include <linux/isdn/capicmd.h>
41 MODULE_DESCRIPTION("CAPI4Linux: Userspace /dev/capi20 interface");
42 MODULE_AUTHOR("Carsten Paeth");
43 MODULE_LICENSE("GPL");
45 /* -------- driver information -------------------------------------- */
47 static DEFINE_MUTEX(capi_mutex
);
48 static struct class *capi_class
;
49 static int capi_major
= 68; /* allocated */
51 module_param_named(major
, capi_major
, uint
, 0);
53 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
54 #define CAPINC_NR_PORTS 32
55 #define CAPINC_MAX_PORTS 256
57 static int capi_ttyminors
= CAPINC_NR_PORTS
;
59 module_param_named(ttyminors
, capi_ttyminors
, uint
, 0);
60 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
62 /* -------- defines ------------------------------------------------- */
64 #define CAPINC_MAX_RECVQUEUE 10
65 #define CAPINC_MAX_SENDQUEUE 10
66 #define CAPI_MAX_BLKSIZE 2048
68 /* -------- data structures ----------------------------------------- */
74 struct ackqueue_entry
{
75 struct list_head list
;
84 struct capi20_appl
*ap
;
93 struct sk_buff_head inqueue
;
95 struct sk_buff_head outqueue
;
97 struct sk_buff
*outskb
;
101 struct list_head ackqueue
;
107 struct list_head list
;
109 struct capidev
*cdev
;
110 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
111 struct capiminor
*minorp
;
112 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
116 struct list_head list
;
117 struct capi20_appl ap
;
121 struct sk_buff_head recvqueue
;
122 wait_queue_head_t recvwait
;
124 struct list_head nccis
;
129 /* -------- global variables ---------------------------------------- */
131 static DEFINE_MUTEX(capidev_list_lock
);
132 static LIST_HEAD(capidev_list
);
134 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
136 static DEFINE_SPINLOCK(capiminors_lock
);
137 static struct capiminor
**capiminors
;
139 static struct tty_driver
*capinc_tty_driver
;
141 /* -------- datahandles --------------------------------------------- */
143 static int capiminor_add_ack(struct capiminor
*mp
, u16 datahandle
)
145 struct ackqueue_entry
*n
;
147 n
= kmalloc(sizeof(*n
), GFP_ATOMIC
);
149 printk(KERN_ERR
"capi: alloc datahandle failed\n");
152 n
->datahandle
= datahandle
;
153 INIT_LIST_HEAD(&n
->list
);
154 spin_lock_bh(&mp
->ackqlock
);
155 list_add_tail(&n
->list
, &mp
->ackqueue
);
157 spin_unlock_bh(&mp
->ackqlock
);
161 static int capiminor_del_ack(struct capiminor
*mp
, u16 datahandle
)
163 struct ackqueue_entry
*p
, *tmp
;
165 spin_lock_bh(&mp
->ackqlock
);
166 list_for_each_entry_safe(p
, tmp
, &mp
->ackqueue
, list
) {
167 if (p
->datahandle
== datahandle
) {
170 spin_unlock_bh(&mp
->ackqlock
);
175 spin_unlock_bh(&mp
->ackqlock
);
179 static void capiminor_del_all_ack(struct capiminor
*mp
)
181 struct ackqueue_entry
*p
, *tmp
;
183 list_for_each_entry_safe(p
, tmp
, &mp
->ackqueue
, list
) {
191 /* -------- struct capiminor ---------------------------------------- */
193 static const struct tty_port_operations capiminor_port_ops
; /* we have none */
195 static struct capiminor
*capiminor_alloc(struct capi20_appl
*ap
, u32 ncci
)
197 struct capiminor
*mp
;
201 mp
= kzalloc(sizeof(*mp
), GFP_KERNEL
);
203 printk(KERN_ERR
"capi: can't alloc capiminor\n");
207 kref_init(&mp
->kref
);
211 INIT_LIST_HEAD(&mp
->ackqueue
);
212 spin_lock_init(&mp
->ackqlock
);
214 skb_queue_head_init(&mp
->inqueue
);
215 skb_queue_head_init(&mp
->outqueue
);
216 spin_lock_init(&mp
->outlock
);
218 tty_port_init(&mp
->port
);
219 mp
->port
.ops
= &capiminor_port_ops
;
221 /* Allocate the least unused minor number. */
222 spin_lock(&capiminors_lock
);
223 for (minor
= 0; minor
< capi_ttyminors
; minor
++)
224 if (!capiminors
[minor
]) {
225 capiminors
[minor
] = mp
;
228 spin_unlock(&capiminors_lock
);
230 if (minor
== capi_ttyminors
) {
231 printk(KERN_NOTICE
"capi: out of minors\n");
237 dev
= tty_register_device(capinc_tty_driver
, minor
, NULL
);
244 spin_lock(&capiminors_lock
);
245 capiminors
[minor
] = NULL
;
246 spin_unlock(&capiminors_lock
);
253 static void capiminor_destroy(struct kref
*kref
)
255 struct capiminor
*mp
= container_of(kref
, struct capiminor
, kref
);
257 kfree_skb(mp
->outskb
);
258 skb_queue_purge(&mp
->inqueue
);
259 skb_queue_purge(&mp
->outqueue
);
260 capiminor_del_all_ack(mp
);
264 static struct capiminor
*capiminor_get(unsigned int minor
)
266 struct capiminor
*mp
;
268 spin_lock(&capiminors_lock
);
269 mp
= capiminors
[minor
];
272 spin_unlock(&capiminors_lock
);
277 static inline void capiminor_put(struct capiminor
*mp
)
279 kref_put(&mp
->kref
, capiminor_destroy
);
282 static void capiminor_free(struct capiminor
*mp
)
284 tty_unregister_device(capinc_tty_driver
, mp
->minor
);
286 spin_lock(&capiminors_lock
);
287 capiminors
[mp
->minor
] = NULL
;
288 spin_unlock(&capiminors_lock
);
293 /* -------- struct capincci ----------------------------------------- */
295 static void capincci_alloc_minor(struct capidev
*cdev
, struct capincci
*np
)
297 if (cdev
->userflags
& CAPIFLAG_HIGHJACKING
)
298 np
->minorp
= capiminor_alloc(&cdev
->ap
, np
->ncci
);
301 static void capincci_free_minor(struct capincci
*np
)
303 struct capiminor
*mp
= np
->minorp
;
304 struct tty_struct
*tty
;
307 tty
= tty_port_tty_get(&mp
->port
);
317 static inline unsigned int capincci_minor_opencount(struct capincci
*np
)
319 struct capiminor
*mp
= np
->minorp
;
320 unsigned int count
= 0;
321 struct tty_struct
*tty
;
324 tty
= tty_port_tty_get(&mp
->port
);
333 #else /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
336 capincci_alloc_minor(struct capidev
*cdev
, struct capincci
*np
) { }
337 static inline void capincci_free_minor(struct capincci
*np
) { }
339 #endif /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
341 static struct capincci
*capincci_alloc(struct capidev
*cdev
, u32 ncci
)
345 np
= kzalloc(sizeof(*np
), GFP_KERNEL
);
351 capincci_alloc_minor(cdev
, np
);
353 list_add_tail(&np
->list
, &cdev
->nccis
);
358 static void capincci_free(struct capidev
*cdev
, u32 ncci
)
360 struct capincci
*np
, *tmp
;
362 list_for_each_entry_safe(np
, tmp
, &cdev
->nccis
, list
)
363 if (ncci
== 0xffffffff || np
->ncci
== ncci
) {
364 capincci_free_minor(np
);
370 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
371 static struct capincci
*capincci_find(struct capidev
*cdev
, u32 ncci
)
375 list_for_each_entry(np
, &cdev
->nccis
, list
)
376 if (np
->ncci
== ncci
)
381 /* -------- handle data queue --------------------------------------- */
383 static struct sk_buff
*
384 gen_data_b3_resp_for(struct capiminor
*mp
, struct sk_buff
*skb
)
386 struct sk_buff
*nskb
;
387 nskb
= alloc_skb(CAPI_DATA_B3_RESP_LEN
, GFP_KERNEL
);
389 u16 datahandle
= CAPIMSG_U16(skb
->data
, CAPIMSG_BASELEN
+ 4 + 4 + 2);
390 unsigned char *s
= skb_put(nskb
, CAPI_DATA_B3_RESP_LEN
);
391 capimsg_setu16(s
, 0, CAPI_DATA_B3_RESP_LEN
);
392 capimsg_setu16(s
, 2, mp
->ap
->applid
);
393 capimsg_setu8 (s
, 4, CAPI_DATA_B3
);
394 capimsg_setu8 (s
, 5, CAPI_RESP
);
395 capimsg_setu16(s
, 6, atomic_inc_return(&mp
->msgid
));
396 capimsg_setu32(s
, 8, mp
->ncci
);
397 capimsg_setu16(s
, 12, datahandle
);
402 static int handle_recv_skb(struct capiminor
*mp
, struct sk_buff
*skb
)
404 unsigned int datalen
= skb
->len
- CAPIMSG_LEN(skb
->data
);
405 struct tty_struct
*tty
;
406 struct sk_buff
*nskb
;
407 u16 errcode
, datahandle
;
408 struct tty_ldisc
*ld
;
411 tty
= tty_port_tty_get(&mp
->port
);
413 pr_debug("capi: currently no receiver\n");
417 ld
= tty_ldisc_ref(tty
);
419 /* fatal error, do not requeue */
425 if (ld
->ops
->receive_buf
== NULL
) {
426 pr_debug("capi: ldisc has no receive_buf function\n");
427 /* fatal error, do not requeue */
431 pr_debug("capi: recv tty throttled\n");
435 if (tty
->receive_room
< datalen
) {
436 pr_debug("capi: no room in tty\n");
440 nskb
= gen_data_b3_resp_for(mp
, skb
);
442 printk(KERN_ERR
"capi: gen_data_b3_resp failed\n");
446 datahandle
= CAPIMSG_U16(skb
->data
, CAPIMSG_BASELEN
+ 4);
448 errcode
= capi20_put_message(mp
->ap
, nskb
);
450 if (errcode
== CAPI_NOERROR
) {
451 skb_pull(skb
, CAPIMSG_LEN(skb
->data
));
452 pr_debug("capi: DATA_B3_RESP %u len=%d => ldisc\n",
453 datahandle
, skb
->len
);
454 ld
->ops
->receive_buf(tty
, skb
->data
, NULL
, skb
->len
);
456 printk(KERN_ERR
"capi: send DATA_B3_RESP failed=%x\n",
460 if (errcode
== CAPI_SENDQUEUEFULL
)
476 static void handle_minor_recv(struct capiminor
*mp
)
480 while ((skb
= skb_dequeue(&mp
->inqueue
)) != NULL
)
481 if (handle_recv_skb(mp
, skb
) < 0) {
482 skb_queue_head(&mp
->inqueue
, skb
);
487 static void handle_minor_send(struct capiminor
*mp
)
489 struct tty_struct
*tty
;
495 tty
= tty_port_tty_get(&mp
->port
);
499 if (mp
->ttyoutstop
) {
500 pr_debug("capi: send: tty stopped\n");
506 spin_lock_bh(&mp
->outlock
);
507 skb
= __skb_dequeue(&mp
->outqueue
);
509 spin_unlock_bh(&mp
->outlock
);
514 spin_unlock_bh(&mp
->outlock
);
516 datahandle
= atomic_inc_return(&mp
->datahandle
);
517 skb_push(skb
, CAPI_DATA_B3_REQ_LEN
);
518 memset(skb
->data
, 0, CAPI_DATA_B3_REQ_LEN
);
519 capimsg_setu16(skb
->data
, 0, CAPI_DATA_B3_REQ_LEN
);
520 capimsg_setu16(skb
->data
, 2, mp
->ap
->applid
);
521 capimsg_setu8 (skb
->data
, 4, CAPI_DATA_B3
);
522 capimsg_setu8 (skb
->data
, 5, CAPI_REQ
);
523 capimsg_setu16(skb
->data
, 6, atomic_inc_return(&mp
->msgid
));
524 capimsg_setu32(skb
->data
, 8, mp
->ncci
); /* NCCI */
525 capimsg_setu32(skb
->data
, 12, (u32
)(long)skb
->data
);/* Data32 */
526 capimsg_setu16(skb
->data
, 16, len
); /* Data length */
527 capimsg_setu16(skb
->data
, 18, datahandle
);
528 capimsg_setu16(skb
->data
, 20, 0); /* Flags */
530 if (capiminor_add_ack(mp
, datahandle
) < 0) {
531 skb_pull(skb
, CAPI_DATA_B3_REQ_LEN
);
533 spin_lock_bh(&mp
->outlock
);
534 __skb_queue_head(&mp
->outqueue
, skb
);
536 spin_unlock_bh(&mp
->outlock
);
540 errcode
= capi20_put_message(mp
->ap
, skb
);
541 if (errcode
== CAPI_NOERROR
) {
542 pr_debug("capi: DATA_B3_REQ %u len=%u\n",
546 capiminor_del_ack(mp
, datahandle
);
548 if (errcode
== CAPI_SENDQUEUEFULL
) {
549 skb_pull(skb
, CAPI_DATA_B3_REQ_LEN
);
551 spin_lock_bh(&mp
->outlock
);
552 __skb_queue_head(&mp
->outqueue
, skb
);
554 spin_unlock_bh(&mp
->outlock
);
559 /* ups, drop packet */
560 printk(KERN_ERR
"capi: put_message = %x\n", errcode
);
566 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
567 /* -------- function called by lower level -------------------------- */
569 static void capi_recv_message(struct capi20_appl
*ap
, struct sk_buff
*skb
)
571 struct capidev
*cdev
= ap
->private;
572 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
573 struct tty_struct
*tty
;
574 struct capiminor
*mp
;
577 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
579 mutex_lock(&cdev
->lock
);
581 if (CAPIMSG_CMD(skb
->data
) == CAPI_CONNECT_B3_CONF
) {
582 u16 info
= CAPIMSG_U16(skb
->data
, 12); // Info field
583 if ((info
& 0xff00) == 0)
584 capincci_alloc(cdev
, CAPIMSG_NCCI(skb
->data
));
586 if (CAPIMSG_CMD(skb
->data
) == CAPI_CONNECT_B3_IND
)
587 capincci_alloc(cdev
, CAPIMSG_NCCI(skb
->data
));
589 if (CAPIMSG_COMMAND(skb
->data
) != CAPI_DATA_B3
) {
590 skb_queue_tail(&cdev
->recvqueue
, skb
);
591 wake_up_interruptible(&cdev
->recvwait
);
595 #ifndef CONFIG_ISDN_CAPI_MIDDLEWARE
596 skb_queue_tail(&cdev
->recvqueue
, skb
);
597 wake_up_interruptible(&cdev
->recvwait
);
599 #else /* CONFIG_ISDN_CAPI_MIDDLEWARE */
601 np
= capincci_find(cdev
, CAPIMSG_CONTROL(skb
->data
));
603 printk(KERN_ERR
"BUG: capi_signal: ncci not found\n");
604 skb_queue_tail(&cdev
->recvqueue
, skb
);
605 wake_up_interruptible(&cdev
->recvwait
);
611 skb_queue_tail(&cdev
->recvqueue
, skb
);
612 wake_up_interruptible(&cdev
->recvwait
);
615 if (CAPIMSG_SUBCOMMAND(skb
->data
) == CAPI_IND
) {
616 datahandle
= CAPIMSG_U16(skb
->data
, CAPIMSG_BASELEN
+ 4 + 4 + 2);
617 pr_debug("capi_signal: DATA_B3_IND %u len=%d\n",
618 datahandle
, skb
->len
-CAPIMSG_LEN(skb
->data
));
619 skb_queue_tail(&mp
->inqueue
, skb
);
621 handle_minor_recv(mp
);
623 } else if (CAPIMSG_SUBCOMMAND(skb
->data
) == CAPI_CONF
) {
625 datahandle
= CAPIMSG_U16(skb
->data
, CAPIMSG_BASELEN
+ 4);
626 pr_debug("capi_signal: DATA_B3_CONF %u 0x%x\n",
628 CAPIMSG_U16(skb
->data
, CAPIMSG_BASELEN
+ 4 + 2));
630 capiminor_del_ack(mp
, datahandle
);
631 tty
= tty_port_tty_get(&mp
->port
);
636 handle_minor_send(mp
);
639 /* ups, let capi application handle it :-) */
640 skb_queue_tail(&cdev
->recvqueue
, skb
);
641 wake_up_interruptible(&cdev
->recvwait
);
643 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
646 mutex_unlock(&cdev
->lock
);
649 /* -------- file_operations for capidev ----------------------------- */
652 capi_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
654 struct capidev
*cdev
= file
->private_data
;
659 if (!cdev
->ap
.applid
)
662 skb
= skb_dequeue(&cdev
->recvqueue
);
664 if (file
->f_flags
& O_NONBLOCK
)
666 err
= wait_event_interruptible(cdev
->recvwait
,
667 (skb
= skb_dequeue(&cdev
->recvqueue
)));
671 if (skb
->len
> count
) {
672 skb_queue_head(&cdev
->recvqueue
, skb
);
675 if (copy_to_user(buf
, skb
->data
, skb
->len
)) {
676 skb_queue_head(&cdev
->recvqueue
, skb
);
687 capi_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
689 struct capidev
*cdev
= file
->private_data
;
693 if (!cdev
->ap
.applid
)
696 skb
= alloc_skb(count
, GFP_USER
);
700 if (copy_from_user(skb_put(skb
, count
), buf
, count
)) {
704 mlen
= CAPIMSG_LEN(skb
->data
);
705 if (CAPIMSG_CMD(skb
->data
) == CAPI_DATA_B3_REQ
) {
706 if ((size_t)(mlen
+ CAPIMSG_DATALEN(skb
->data
)) != count
) {
716 CAPIMSG_SETAPPID(skb
->data
, cdev
->ap
.applid
);
718 if (CAPIMSG_CMD(skb
->data
) == CAPI_DISCONNECT_B3_RESP
) {
719 mutex_lock(&cdev
->lock
);
720 capincci_free(cdev
, CAPIMSG_NCCI(skb
->data
));
721 mutex_unlock(&cdev
->lock
);
724 cdev
->errcode
= capi20_put_message(&cdev
->ap
, skb
);
734 capi_poll(struct file
*file
, poll_table
*wait
)
736 struct capidev
*cdev
= file
->private_data
;
737 unsigned int mask
= 0;
739 if (!cdev
->ap
.applid
)
742 poll_wait(file
, &(cdev
->recvwait
), wait
);
743 mask
= POLLOUT
| POLLWRNORM
;
744 if (!skb_queue_empty(&cdev
->recvqueue
))
745 mask
|= POLLIN
| POLLRDNORM
;
750 capi_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
752 struct capidev
*cdev
= file
->private_data
;
753 capi_ioctl_struct data
;
754 int retval
= -EINVAL
;
755 void __user
*argp
= (void __user
*)arg
;
759 mutex_lock(&cdev
->lock
);
761 if (cdev
->ap
.applid
) {
765 if (copy_from_user(&cdev
->ap
.rparam
, argp
,
766 sizeof(struct capi_register_params
))) {
770 cdev
->ap
.private = cdev
;
771 cdev
->ap
.recv_message
= capi_recv_message
;
772 cdev
->errcode
= capi20_register(&cdev
->ap
);
773 retval
= (int)cdev
->ap
.applid
;
780 mutex_unlock(&cdev
->lock
);
783 case CAPI_GET_VERSION
:
784 if (copy_from_user(&data
.contr
, argp
,
787 cdev
->errcode
= capi20_get_version(data
.contr
, &data
.version
);
790 if (copy_to_user(argp
, &data
.version
,
791 sizeof(data
.version
)))
795 case CAPI_GET_SERIAL
:
796 if (copy_from_user(&data
.contr
, argp
,
799 cdev
->errcode
= capi20_get_serial(data
.contr
, data
.serial
);
802 if (copy_to_user(argp
, data
.serial
,
803 sizeof(data
.serial
)))
807 case CAPI_GET_PROFILE
:
808 if (copy_from_user(&data
.contr
, argp
,
812 if (data
.contr
== 0) {
813 cdev
->errcode
= capi20_get_profile(data
.contr
, &data
.profile
);
817 retval
= copy_to_user(argp
,
818 &data
.profile
.ncontroller
,
819 sizeof(data
.profile
.ncontroller
));
822 cdev
->errcode
= capi20_get_profile(data
.contr
, &data
.profile
);
826 retval
= copy_to_user(argp
, &data
.profile
,
827 sizeof(data
.profile
));
833 case CAPI_GET_MANUFACTURER
:
834 if (copy_from_user(&data
.contr
, argp
,
837 cdev
->errcode
= capi20_get_manufacturer(data
.contr
, data
.manufacturer
);
841 if (copy_to_user(argp
, data
.manufacturer
,
842 sizeof(data
.manufacturer
)))
847 case CAPI_GET_ERRCODE
:
848 data
.errcode
= cdev
->errcode
;
849 cdev
->errcode
= CAPI_NOERROR
;
851 if (copy_to_user(argp
, &data
.errcode
,
852 sizeof(data
.errcode
)))
858 if (capi20_isinstalled() == CAPI_NOERROR
)
862 case CAPI_MANUFACTURER_CMD
: {
863 struct capi_manufacturer_cmd mcmd
;
864 if (!capable(CAP_SYS_ADMIN
))
866 if (copy_from_user(&mcmd
, argp
, sizeof(mcmd
)))
868 return capi20_manufacturer(mcmd
.cmd
, mcmd
.data
);
871 case CAPI_CLR_FLAGS
: {
874 if (copy_from_user(&userflags
, argp
, sizeof(userflags
)))
877 mutex_lock(&cdev
->lock
);
878 if (cmd
== CAPI_SET_FLAGS
)
879 cdev
->userflags
|= userflags
;
881 cdev
->userflags
&= ~userflags
;
882 mutex_unlock(&cdev
->lock
);
886 if (copy_to_user(argp
, &cdev
->userflags
,
887 sizeof(cdev
->userflags
)))
891 #ifndef CONFIG_ISDN_CAPI_MIDDLEWARE
892 case CAPI_NCCI_OPENCOUNT
:
895 #else /* CONFIG_ISDN_CAPI_MIDDLEWARE */
896 case CAPI_NCCI_OPENCOUNT
: {
897 struct capincci
*nccip
;
901 if (copy_from_user(&ncci
, argp
, sizeof(ncci
)))
904 mutex_lock(&cdev
->lock
);
905 nccip
= capincci_find(cdev
, (u32
)ncci
);
907 count
= capincci_minor_opencount(nccip
);
908 mutex_unlock(&cdev
->lock
);
912 case CAPI_NCCI_GETUNIT
: {
913 struct capincci
*nccip
;
914 struct capiminor
*mp
;
918 if (copy_from_user(&ncci
, argp
, sizeof(ncci
)))
921 mutex_lock(&cdev
->lock
);
922 nccip
= capincci_find(cdev
, (u32
)ncci
);
928 mutex_unlock(&cdev
->lock
);
931 #endif /* CONFIG_ISDN_CAPI_MIDDLEWARE */
939 capi_unlocked_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
943 mutex_lock(&capi_mutex
);
944 ret
= capi_ioctl(file
, cmd
, arg
);
945 mutex_unlock(&capi_mutex
);
950 static int capi_open(struct inode
*inode
, struct file
*file
)
952 struct capidev
*cdev
;
954 cdev
= kzalloc(sizeof(*cdev
), GFP_KERNEL
);
958 mutex_init(&cdev
->lock
);
959 skb_queue_head_init(&cdev
->recvqueue
);
960 init_waitqueue_head(&cdev
->recvwait
);
961 INIT_LIST_HEAD(&cdev
->nccis
);
962 file
->private_data
= cdev
;
964 mutex_lock(&capidev_list_lock
);
965 list_add_tail(&cdev
->list
, &capidev_list
);
966 mutex_unlock(&capidev_list_lock
);
968 return nonseekable_open(inode
, file
);
971 static int capi_release(struct inode
*inode
, struct file
*file
)
973 struct capidev
*cdev
= file
->private_data
;
975 mutex_lock(&capidev_list_lock
);
976 list_del(&cdev
->list
);
977 mutex_unlock(&capidev_list_lock
);
980 capi20_release(&cdev
->ap
);
981 skb_queue_purge(&cdev
->recvqueue
);
982 capincci_free(cdev
, 0xffffffff);
988 static const struct file_operations capi_fops
=
990 .owner
= THIS_MODULE
,
995 .unlocked_ioctl
= capi_unlocked_ioctl
,
997 .release
= capi_release
,
1000 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
1001 /* -------- tty_operations for capincci ----------------------------- */
1004 capinc_tty_install(struct tty_driver
*driver
, struct tty_struct
*tty
)
1006 struct capiminor
*mp
= capiminor_get(tty
->index
);
1007 int ret
= tty_standard_install(driver
, tty
);
1010 tty
->driver_data
= mp
;
1016 static void capinc_tty_cleanup(struct tty_struct
*tty
)
1018 struct capiminor
*mp
= tty
->driver_data
;
1019 tty
->driver_data
= NULL
;
1023 static int capinc_tty_open(struct tty_struct
*tty
, struct file
*filp
)
1025 struct capiminor
*mp
= tty
->driver_data
;
1028 err
= tty_port_open(&mp
->port
, tty
, filp
);
1032 handle_minor_recv(mp
);
1036 static void capinc_tty_close(struct tty_struct
*tty
, struct file
*filp
)
1038 struct capiminor
*mp
= tty
->driver_data
;
1040 tty_port_close(&mp
->port
, tty
, filp
);
1043 static int capinc_tty_write(struct tty_struct
*tty
,
1044 const unsigned char *buf
, int count
)
1046 struct capiminor
*mp
= tty
->driver_data
;
1047 struct sk_buff
*skb
;
1049 pr_debug("capinc_tty_write(count=%d)\n", count
);
1051 spin_lock_bh(&mp
->outlock
);
1055 __skb_queue_tail(&mp
->outqueue
, skb
);
1056 mp
->outbytes
+= skb
->len
;
1059 skb
= alloc_skb(CAPI_DATA_B3_REQ_LEN
+ count
, GFP_ATOMIC
);
1061 printk(KERN_ERR
"capinc_tty_write: alloc_skb failed\n");
1062 spin_unlock_bh(&mp
->outlock
);
1066 skb_reserve(skb
, CAPI_DATA_B3_REQ_LEN
);
1067 memcpy(skb_put(skb
, count
), buf
, count
);
1069 __skb_queue_tail(&mp
->outqueue
, skb
);
1070 mp
->outbytes
+= skb
->len
;
1071 spin_unlock_bh(&mp
->outlock
);
1073 handle_minor_send(mp
);
1078 static int capinc_tty_put_char(struct tty_struct
*tty
, unsigned char ch
)
1080 struct capiminor
*mp
= tty
->driver_data
;
1081 bool invoke_send
= false;
1082 struct sk_buff
*skb
;
1085 pr_debug("capinc_put_char(%u)\n", ch
);
1087 spin_lock_bh(&mp
->outlock
);
1090 if (skb_tailroom(skb
) > 0) {
1091 *(skb_put(skb
, 1)) = ch
;
1095 __skb_queue_tail(&mp
->outqueue
, skb
);
1096 mp
->outbytes
+= skb
->len
;
1100 skb
= alloc_skb(CAPI_DATA_B3_REQ_LEN
+ CAPI_MAX_BLKSIZE
, GFP_ATOMIC
);
1102 skb_reserve(skb
, CAPI_DATA_B3_REQ_LEN
);
1103 *(skb_put(skb
, 1)) = ch
;
1106 printk(KERN_ERR
"capinc_put_char: char %u lost\n", ch
);
1111 spin_unlock_bh(&mp
->outlock
);
1114 handle_minor_send(mp
);
1119 static void capinc_tty_flush_chars(struct tty_struct
*tty
)
1121 struct capiminor
*mp
= tty
->driver_data
;
1122 struct sk_buff
*skb
;
1124 pr_debug("capinc_tty_flush_chars\n");
1126 spin_lock_bh(&mp
->outlock
);
1130 __skb_queue_tail(&mp
->outqueue
, skb
);
1131 mp
->outbytes
+= skb
->len
;
1132 spin_unlock_bh(&mp
->outlock
);
1134 handle_minor_send(mp
);
1136 spin_unlock_bh(&mp
->outlock
);
1138 handle_minor_recv(mp
);
1141 static int capinc_tty_write_room(struct tty_struct
*tty
)
1143 struct capiminor
*mp
= tty
->driver_data
;
1146 room
= CAPINC_MAX_SENDQUEUE
-skb_queue_len(&mp
->outqueue
);
1147 room
*= CAPI_MAX_BLKSIZE
;
1148 pr_debug("capinc_tty_write_room = %d\n", room
);
1152 static int capinc_tty_chars_in_buffer(struct tty_struct
*tty
)
1154 struct capiminor
*mp
= tty
->driver_data
;
1156 pr_debug("capinc_tty_chars_in_buffer = %d nack=%d sq=%d rq=%d\n",
1157 mp
->outbytes
, mp
->nack
,
1158 skb_queue_len(&mp
->outqueue
),
1159 skb_queue_len(&mp
->inqueue
));
1160 return mp
->outbytes
;
1163 static int capinc_tty_ioctl(struct tty_struct
*tty
,
1164 unsigned int cmd
, unsigned long arg
)
1166 return -ENOIOCTLCMD
;
1169 static void capinc_tty_set_termios(struct tty_struct
*tty
, struct ktermios
*old
)
1171 pr_debug("capinc_tty_set_termios\n");
1174 static void capinc_tty_throttle(struct tty_struct
*tty
)
1176 struct capiminor
*mp
= tty
->driver_data
;
1177 pr_debug("capinc_tty_throttle\n");
1181 static void capinc_tty_unthrottle(struct tty_struct
*tty
)
1183 struct capiminor
*mp
= tty
->driver_data
;
1185 pr_debug("capinc_tty_unthrottle\n");
1187 handle_minor_recv(mp
);
1190 static void capinc_tty_stop(struct tty_struct
*tty
)
1192 struct capiminor
*mp
= tty
->driver_data
;
1194 pr_debug("capinc_tty_stop\n");
1198 static void capinc_tty_start(struct tty_struct
*tty
)
1200 struct capiminor
*mp
= tty
->driver_data
;
1202 pr_debug("capinc_tty_start\n");
1204 handle_minor_send(mp
);
1207 static void capinc_tty_hangup(struct tty_struct
*tty
)
1209 struct capiminor
*mp
= tty
->driver_data
;
1211 pr_debug("capinc_tty_hangup\n");
1212 tty_port_hangup(&mp
->port
);
1215 static int capinc_tty_break_ctl(struct tty_struct
*tty
, int state
)
1217 pr_debug("capinc_tty_break_ctl(%d)\n", state
);
1221 static void capinc_tty_flush_buffer(struct tty_struct
*tty
)
1223 pr_debug("capinc_tty_flush_buffer\n");
1226 static void capinc_tty_set_ldisc(struct tty_struct
*tty
)
1228 pr_debug("capinc_tty_set_ldisc\n");
1231 static void capinc_tty_send_xchar(struct tty_struct
*tty
, char ch
)
1233 pr_debug("capinc_tty_send_xchar(%d)\n", ch
);
1236 static const struct tty_operations capinc_ops
= {
1237 .open
= capinc_tty_open
,
1238 .close
= capinc_tty_close
,
1239 .write
= capinc_tty_write
,
1240 .put_char
= capinc_tty_put_char
,
1241 .flush_chars
= capinc_tty_flush_chars
,
1242 .write_room
= capinc_tty_write_room
,
1243 .chars_in_buffer
= capinc_tty_chars_in_buffer
,
1244 .ioctl
= capinc_tty_ioctl
,
1245 .set_termios
= capinc_tty_set_termios
,
1246 .throttle
= capinc_tty_throttle
,
1247 .unthrottle
= capinc_tty_unthrottle
,
1248 .stop
= capinc_tty_stop
,
1249 .start
= capinc_tty_start
,
1250 .hangup
= capinc_tty_hangup
,
1251 .break_ctl
= capinc_tty_break_ctl
,
1252 .flush_buffer
= capinc_tty_flush_buffer
,
1253 .set_ldisc
= capinc_tty_set_ldisc
,
1254 .send_xchar
= capinc_tty_send_xchar
,
1255 .install
= capinc_tty_install
,
1256 .cleanup
= capinc_tty_cleanup
,
1259 static int __init
capinc_tty_init(void)
1261 struct tty_driver
*drv
;
1264 if (capi_ttyminors
> CAPINC_MAX_PORTS
)
1265 capi_ttyminors
= CAPINC_MAX_PORTS
;
1266 if (capi_ttyminors
<= 0)
1267 capi_ttyminors
= CAPINC_NR_PORTS
;
1269 capiminors
= kzalloc(sizeof(struct capi_minor
*) * capi_ttyminors
,
1274 drv
= alloc_tty_driver(capi_ttyminors
);
1279 drv
->driver_name
= "capi_nc";
1282 drv
->minor_start
= 0;
1283 drv
->type
= TTY_DRIVER_TYPE_SERIAL
;
1284 drv
->subtype
= SERIAL_TYPE_NORMAL
;
1285 drv
->init_termios
= tty_std_termios
;
1286 drv
->init_termios
.c_iflag
= ICRNL
;
1287 drv
->init_termios
.c_oflag
= OPOST
| ONLCR
;
1288 drv
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
1289 drv
->init_termios
.c_lflag
= 0;
1291 TTY_DRIVER_REAL_RAW
| TTY_DRIVER_RESET_TERMIOS
|
1292 TTY_DRIVER_DYNAMIC_DEV
;
1293 tty_set_operations(drv
, &capinc_ops
);
1295 err
= tty_register_driver(drv
);
1297 put_tty_driver(drv
);
1299 printk(KERN_ERR
"Couldn't register capi_nc driver\n");
1302 capinc_tty_driver
= drv
;
1306 static void __exit
capinc_tty_exit(void)
1308 tty_unregister_driver(capinc_tty_driver
);
1309 put_tty_driver(capinc_tty_driver
);
1313 #else /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
1315 static inline int capinc_tty_init(void)
1320 static inline void capinc_tty_exit(void) { }
1322 #endif /* !CONFIG_ISDN_CAPI_MIDDLEWARE */
1324 /* -------- /proc functions ----------------------------------------- */
1327 * /proc/capi/capi20:
1328 * minor applid nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt
1330 static int capi20_proc_show(struct seq_file
*m
, void *v
)
1332 struct capidev
*cdev
;
1333 struct list_head
*l
;
1335 mutex_lock(&capidev_list_lock
);
1336 list_for_each(l
, &capidev_list
) {
1337 cdev
= list_entry(l
, struct capidev
, list
);
1338 seq_printf(m
, "0 %d %lu %lu %lu %lu\n",
1340 cdev
->ap
.nrecvctlpkt
,
1341 cdev
->ap
.nrecvdatapkt
,
1342 cdev
->ap
.nsentctlpkt
,
1343 cdev
->ap
.nsentdatapkt
);
1345 mutex_unlock(&capidev_list_lock
);
1349 static int capi20_proc_open(struct inode
*inode
, struct file
*file
)
1351 return single_open(file
, capi20_proc_show
, NULL
);
1354 static const struct file_operations capi20_proc_fops
= {
1355 .owner
= THIS_MODULE
,
1356 .open
= capi20_proc_open
,
1358 .llseek
= seq_lseek
,
1359 .release
= single_release
,
1363 * /proc/capi/capi20ncci:
1366 static int capi20ncci_proc_show(struct seq_file
*m
, void *v
)
1368 struct capidev
*cdev
;
1369 struct capincci
*np
;
1371 mutex_lock(&capidev_list_lock
);
1372 list_for_each_entry(cdev
, &capidev_list
, list
) {
1373 mutex_lock(&cdev
->lock
);
1374 list_for_each_entry(np
, &cdev
->nccis
, list
)
1375 seq_printf(m
, "%d 0x%x\n", cdev
->ap
.applid
, np
->ncci
);
1376 mutex_unlock(&cdev
->lock
);
1378 mutex_unlock(&capidev_list_lock
);
1382 static int capi20ncci_proc_open(struct inode
*inode
, struct file
*file
)
1384 return single_open(file
, capi20ncci_proc_show
, NULL
);
1387 static const struct file_operations capi20ncci_proc_fops
= {
1388 .owner
= THIS_MODULE
,
1389 .open
= capi20ncci_proc_open
,
1391 .llseek
= seq_lseek
,
1392 .release
= single_release
,
1395 static void __init
proc_init(void)
1397 proc_create("capi/capi20", 0, NULL
, &capi20_proc_fops
);
1398 proc_create("capi/capi20ncci", 0, NULL
, &capi20ncci_proc_fops
);
1401 static void __exit
proc_exit(void)
1403 remove_proc_entry("capi/capi20", NULL
);
1404 remove_proc_entry("capi/capi20ncci", NULL
);
1407 /* -------- init function and module interface ---------------------- */
1410 static int __init
capi_init(void)
1412 const char *compileinfo
;
1415 major_ret
= register_chrdev(capi_major
, "capi20", &capi_fops
);
1416 if (major_ret
< 0) {
1417 printk(KERN_ERR
"capi20: unable to get major %d\n", capi_major
);
1420 capi_class
= class_create(THIS_MODULE
, "capi");
1421 if (IS_ERR(capi_class
)) {
1422 unregister_chrdev(capi_major
, "capi20");
1423 return PTR_ERR(capi_class
);
1426 device_create(capi_class
, NULL
, MKDEV(capi_major
, 0), NULL
, "capi");
1428 if (capinc_tty_init() < 0) {
1429 device_destroy(capi_class
, MKDEV(capi_major
, 0));
1430 class_destroy(capi_class
);
1431 unregister_chrdev(capi_major
, "capi20");
1437 #ifdef CONFIG_ISDN_CAPI_MIDDLEWARE
1438 compileinfo
= " (middleware)";
1440 compileinfo
= " (no middleware)";
1442 printk(KERN_NOTICE
"CAPI 2.0 started up with major %d%s\n",
1443 capi_major
, compileinfo
);
1448 static void __exit
capi_exit(void)
1452 device_destroy(capi_class
, MKDEV(capi_major
, 0));
1453 class_destroy(capi_class
);
1454 unregister_chrdev(capi_major
, "capi20");
1459 module_init(capi_init
);
1460 module_exit(capi_exit
);