1 /* $Id: kcapi.c,v 1.1.2.8 2004/03/26 19:57:20 armin Exp $
3 * Kernel CAPI 2.0 Module
5 * Copyright 1999 by Carsten Paeth <calle@calle.de>
6 * Copyright 2002 by Kai Germaschewski <kai@germaschewski.name>
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
13 #define CONFIG_AVMB1_COMPAT
16 #include <linux/module.h>
18 #include <linux/interrupt.h>
19 #include <linux/ioport.h>
20 #include <linux/proc_fs.h>
21 #include <linux/seq_file.h>
22 #include <linux/skbuff.h>
23 #include <linux/workqueue.h>
24 #include <linux/capi.h>
25 #include <linux/kernelcapi.h>
26 #include <linux/init.h>
27 #include <linux/moduleparam.h>
28 #include <linux/delay.h>
29 #include <asm/uaccess.h>
30 #include <linux/isdn/capicmd.h>
31 #include <linux/isdn/capiutil.h>
32 #ifdef CONFIG_AVMB1_COMPAT
33 #include <linux/b1lli.h>
35 #include <linux/mutex.h>
37 static char *revision
= "$Revision: 1.1.2.8 $";
39 /* ------------------------------------------------------------- */
41 static int showcapimsgs
= 0;
43 MODULE_DESCRIPTION("CAPI4Linux: kernel CAPI layer");
44 MODULE_AUTHOR("Carsten Paeth");
45 MODULE_LICENSE("GPL");
46 module_param(showcapimsgs
, uint
, 0);
48 /* ------------------------------------------------------------- */
50 struct capi_notifier
{
51 struct work_struct work
;
58 /* ------------------------------------------------------------- */
60 static struct capi_version driver_version
= {2, 0, 1, 1<<4};
61 static char driver_serial
[CAPI_SERIAL_LEN
] = "0004711";
62 static char capi_manufakturer
[64] = "AVM Berlin";
64 #define NCCI2CTRL(ncci) (((ncci) >> 24) & 0x7f)
66 LIST_HEAD(capi_drivers
);
67 DEFINE_RWLOCK(capi_drivers_list_lock
);
69 static DEFINE_RWLOCK(application_lock
);
70 static DEFINE_MUTEX(controller_mutex
);
72 struct capi20_appl
*capi_applications
[CAPI_MAXAPPL
];
73 struct capi_ctr
*capi_cards
[CAPI_MAXCONTR
];
77 /* -------- controller ref counting -------------------------------------- */
79 static inline struct capi_ctr
*
80 capi_ctr_get(struct capi_ctr
*card
)
82 if (!try_module_get(card
->owner
))
88 capi_ctr_put(struct capi_ctr
*card
)
90 module_put(card
->owner
);
93 /* ------------------------------------------------------------- */
95 static inline struct capi_ctr
*get_capi_ctr_by_nr(u16 contr
)
97 if (contr
- 1 >= CAPI_MAXCONTR
)
100 return capi_cards
[contr
- 1];
103 static inline struct capi20_appl
*get_capi_appl_by_nr(u16 applid
)
105 if (applid
- 1 >= CAPI_MAXAPPL
)
108 return capi_applications
[applid
- 1];
111 /* -------- util functions ------------------------------------ */
113 static inline int capi_cmd_valid(u8 cmd
)
118 case CAPI_CONNECT_ACTIVE
:
119 case CAPI_CONNECT_B3_ACTIVE
:
120 case CAPI_CONNECT_B3
:
121 case CAPI_CONNECT_B3_T90_ACTIVE
:
123 case CAPI_DISCONNECT_B3
:
124 case CAPI_DISCONNECT
:
128 case CAPI_MANUFACTURER
:
130 case CAPI_SELECT_B_PROTOCOL
:
136 static inline int capi_subcmd_valid(u8 subcmd
)
148 /* ------------------------------------------------------------ */
150 static void register_appl(struct capi_ctr
*card
, u16 applid
, capi_register_params
*rparam
)
152 card
= capi_ctr_get(card
);
155 card
->register_appl(card
, applid
, rparam
);
157 printk(KERN_WARNING
"%s: cannot get card resources\n", __FUNCTION__
);
161 static void release_appl(struct capi_ctr
*card
, u16 applid
)
163 DBG("applid %#x", applid
);
165 card
->release_appl(card
, applid
);
169 /* -------- KCI_CONTRUP --------------------------------------- */
171 static void notify_up(u32 contr
)
173 struct capi_ctr
*card
= get_capi_ctr_by_nr(contr
);
174 struct capi20_appl
*ap
;
177 if (showcapimsgs
& 1) {
178 printk(KERN_DEBUG
"kcapi: notify up contr %d\n", contr
);
181 printk(KERN_WARNING
"%s: invalid contr %d\n", __FUNCTION__
, contr
);
184 for (applid
= 1; applid
<= CAPI_MAXAPPL
; applid
++) {
185 ap
= get_capi_appl_by_nr(applid
);
186 if (!ap
|| ap
->release_in_progress
) continue;
187 register_appl(card
, applid
, &ap
->rparam
);
188 if (ap
->callback
&& !ap
->release_in_progress
)
189 ap
->callback(KCI_CONTRUP
, contr
, &card
->profile
);
193 /* -------- KCI_CONTRDOWN ------------------------------------- */
195 static void notify_down(u32 contr
)
197 struct capi20_appl
*ap
;
200 if (showcapimsgs
& 1) {
201 printk(KERN_DEBUG
"kcapi: notify down contr %d\n", contr
);
204 for (applid
= 1; applid
<= CAPI_MAXAPPL
; applid
++) {
205 ap
= get_capi_appl_by_nr(applid
);
206 if (ap
&& ap
->callback
&& !ap
->release_in_progress
)
207 ap
->callback(KCI_CONTRDOWN
, contr
, NULL
);
211 static void notify_handler(struct work_struct
*work
)
213 struct capi_notifier
*np
=
214 container_of(work
, struct capi_notifier
, work
);
218 notify_up(np
->controller
);
221 notify_down(np
->controller
);
229 * The notifier will result in adding/deleteing of devices. Devices can
230 * only removed in user process, not in bh.
232 static int notify_push(unsigned int cmd
, u32 controller
, u16 applid
, u32 ncci
)
234 struct capi_notifier
*np
= kmalloc(sizeof(*np
), GFP_ATOMIC
);
239 INIT_WORK(&np
->work
, notify_handler
);
241 np
->controller
= controller
;
245 schedule_work(&np
->work
);
250 /* -------- Receiver ------------------------------------------ */
252 static void recv_handler(struct work_struct
*work
)
255 struct capi20_appl
*ap
=
256 container_of(work
, struct capi20_appl
, recv_work
);
258 if ((!ap
) || (ap
->release_in_progress
))
262 while ((skb
= skb_dequeue(&ap
->recv_queue
))) {
263 if (CAPIMSG_CMD(skb
->data
) == CAPI_DATA_B3_IND
)
268 ap
->recv_message(ap
, skb
);
273 void capi_ctr_handle_message(struct capi_ctr
* card
, u16 appl
, struct sk_buff
*skb
)
275 struct capi20_appl
*ap
;
280 if (card
->cardstate
!= CARD_RUNNING
) {
281 printk(KERN_INFO
"kcapi: controller %d not active, got: %s",
282 card
->cnr
, capi_message2str(skb
->data
));
286 cmd
= CAPIMSG_COMMAND(skb
->data
);
287 subcmd
= CAPIMSG_SUBCOMMAND(skb
->data
);
288 if (cmd
== CAPI_DATA_B3
&& subcmd
== CAPI_IND
) {
289 card
->nrecvdatapkt
++;
290 if (card
->traceflag
> 2) showctl
|= 2;
293 if (card
->traceflag
) showctl
|= 2;
295 showctl
|= (card
->traceflag
& 1);
298 printk(KERN_DEBUG
"kcapi: got [0x%lx] id#%d %s len=%u\n",
299 (unsigned long) card
->cnr
,
300 CAPIMSG_APPID(skb
->data
),
301 capi_cmd2str(cmd
, subcmd
),
302 CAPIMSG_LEN(skb
->data
));
304 printk(KERN_DEBUG
"kcapi: got [0x%lx] %s\n",
305 (unsigned long) card
->cnr
,
306 capi_message2str(skb
->data
));
311 read_lock_irqsave(&application_lock
, flags
);
312 ap
= get_capi_appl_by_nr(CAPIMSG_APPID(skb
->data
));
313 if ((!ap
) || (ap
->release_in_progress
)) {
314 read_unlock_irqrestore(&application_lock
, flags
);
315 printk(KERN_ERR
"kcapi: handle_message: applid %d state released (%s)\n",
316 CAPIMSG_APPID(skb
->data
), capi_message2str(skb
->data
));
319 skb_queue_tail(&ap
->recv_queue
, skb
);
320 schedule_work(&ap
->recv_work
);
321 read_unlock_irqrestore(&application_lock
, flags
);
329 EXPORT_SYMBOL(capi_ctr_handle_message
);
331 void capi_ctr_ready(struct capi_ctr
* card
)
333 card
->cardstate
= CARD_RUNNING
;
335 printk(KERN_NOTICE
"kcapi: card %d \"%s\" ready.\n",
336 card
->cnr
, card
->name
);
338 notify_push(KCI_CONTRUP
, card
->cnr
, 0, 0);
341 EXPORT_SYMBOL(capi_ctr_ready
);
343 void capi_ctr_reseted(struct capi_ctr
* card
)
349 if (card
->cardstate
== CARD_DETECTED
)
352 card
->cardstate
= CARD_DETECTED
;
354 memset(card
->manu
, 0, sizeof(card
->manu
));
355 memset(&card
->version
, 0, sizeof(card
->version
));
356 memset(&card
->profile
, 0, sizeof(card
->profile
));
357 memset(card
->serial
, 0, sizeof(card
->serial
));
359 for (appl
= 1; appl
<= CAPI_MAXAPPL
; appl
++) {
360 struct capi20_appl
*ap
= get_capi_appl_by_nr(appl
);
361 if (!ap
|| ap
->release_in_progress
)
367 printk(KERN_NOTICE
"kcapi: card %d down.\n", card
->cnr
);
369 notify_push(KCI_CONTRDOWN
, card
->cnr
, 0, 0);
372 EXPORT_SYMBOL(capi_ctr_reseted
);
374 void capi_ctr_suspend_output(struct capi_ctr
*card
)
376 if (!card
->blocked
) {
377 printk(KERN_DEBUG
"kcapi: card %d suspend\n", card
->cnr
);
382 EXPORT_SYMBOL(capi_ctr_suspend_output
);
384 void capi_ctr_resume_output(struct capi_ctr
*card
)
387 printk(KERN_DEBUG
"kcapi: card %d resume\n", card
->cnr
);
392 EXPORT_SYMBOL(capi_ctr_resume_output
);
394 /* ------------------------------------------------------------- */
397 attach_capi_ctr(struct capi_ctr
*card
)
401 mutex_lock(&controller_mutex
);
403 for (i
= 0; i
< CAPI_MAXCONTR
; i
++) {
404 if (capi_cards
[i
] == NULL
)
407 if (i
== CAPI_MAXCONTR
) {
408 mutex_unlock(&controller_mutex
);
409 printk(KERN_ERR
"kcapi: out of controller slots\n");
412 capi_cards
[i
] = card
;
414 mutex_unlock(&controller_mutex
);
416 card
->nrecvctlpkt
= 0;
417 card
->nrecvdatapkt
= 0;
418 card
->nsentctlpkt
= 0;
419 card
->nsentdatapkt
= 0;
421 card
->cardstate
= CARD_DETECTED
;
423 card
->traceflag
= showcapimsgs
;
425 sprintf(card
->procfn
, "capi/controllers/%d", card
->cnr
);
426 card
->procent
= create_proc_entry(card
->procfn
, 0, NULL
);
428 card
->procent
->read_proc
=
429 (int (*)(char *,char **,off_t
,int,int *,void *))
431 card
->procent
->data
= card
;
435 printk(KERN_NOTICE
"kcapi: Controller %d: %s attached\n",
436 card
->cnr
, card
->name
);
440 EXPORT_SYMBOL(attach_capi_ctr
);
442 int detach_capi_ctr(struct capi_ctr
*card
)
444 if (card
->cardstate
!= CARD_DETECTED
)
445 capi_ctr_reseted(card
);
450 remove_proc_entry(card
->procfn
, NULL
);
451 card
->procent
= NULL
;
453 capi_cards
[card
->cnr
- 1] = NULL
;
454 printk(KERN_NOTICE
"kcapi: Controller %d: %s unregistered\n",
455 card
->cnr
, card
->name
);
460 EXPORT_SYMBOL(detach_capi_ctr
);
462 void register_capi_driver(struct capi_driver
*driver
)
466 write_lock_irqsave(&capi_drivers_list_lock
, flags
);
467 list_add_tail(&driver
->list
, &capi_drivers
);
468 write_unlock_irqrestore(&capi_drivers_list_lock
, flags
);
471 EXPORT_SYMBOL(register_capi_driver
);
473 void unregister_capi_driver(struct capi_driver
*driver
)
477 write_lock_irqsave(&capi_drivers_list_lock
, flags
);
478 list_del(&driver
->list
);
479 write_unlock_irqrestore(&capi_drivers_list_lock
, flags
);
482 EXPORT_SYMBOL(unregister_capi_driver
);
484 /* ------------------------------------------------------------- */
485 /* -------- CAPI2.0 Interface ---------------------------------- */
486 /* ------------------------------------------------------------- */
488 u16
capi20_isinstalled(void)
491 for (i
= 0; i
< CAPI_MAXCONTR
; i
++) {
492 if (capi_cards
[i
] && capi_cards
[i
]->cardstate
== CARD_RUNNING
)
495 return CAPI_REGNOTINSTALLED
;
498 EXPORT_SYMBOL(capi20_isinstalled
);
500 u16
capi20_register(struct capi20_appl
*ap
)
508 if (ap
->rparam
.datablklen
< 128)
509 return CAPI_LOGBLKSIZETOSMALL
;
511 write_lock_irqsave(&application_lock
, flags
);
513 for (applid
= 1; applid
<= CAPI_MAXAPPL
; applid
++) {
514 if (capi_applications
[applid
- 1] == NULL
)
517 if (applid
> CAPI_MAXAPPL
) {
518 write_unlock_irqrestore(&application_lock
, flags
);
519 return CAPI_TOOMANYAPPLS
;
523 capi_applications
[applid
- 1] = ap
;
526 ap
->nrecvdatapkt
= 0;
528 ap
->nsentdatapkt
= 0;
530 init_MUTEX(&ap
->recv_sem
);
531 skb_queue_head_init(&ap
->recv_queue
);
532 INIT_WORK(&ap
->recv_work
, recv_handler
);
533 ap
->release_in_progress
= 0;
535 write_unlock_irqrestore(&application_lock
, flags
);
537 mutex_lock(&controller_mutex
);
538 for (i
= 0; i
< CAPI_MAXCONTR
; i
++) {
539 if (!capi_cards
[i
] || capi_cards
[i
]->cardstate
!= CARD_RUNNING
)
541 register_appl(capi_cards
[i
], applid
, &ap
->rparam
);
543 mutex_unlock(&controller_mutex
);
545 if (showcapimsgs
& 1) {
546 printk(KERN_DEBUG
"kcapi: appl %d up\n", applid
);
552 EXPORT_SYMBOL(capi20_register
);
554 u16
capi20_release(struct capi20_appl
*ap
)
559 DBG("applid %#x", ap
->applid
);
561 write_lock_irqsave(&application_lock
, flags
);
562 ap
->release_in_progress
= 1;
563 capi_applications
[ap
->applid
- 1] = NULL
;
564 write_unlock_irqrestore(&application_lock
, flags
);
566 mutex_lock(&controller_mutex
);
567 for (i
= 0; i
< CAPI_MAXCONTR
; i
++) {
568 if (!capi_cards
[i
] || capi_cards
[i
]->cardstate
!= CARD_RUNNING
)
570 release_appl(capi_cards
[i
], ap
->applid
);
572 mutex_unlock(&controller_mutex
);
574 flush_scheduled_work();
575 skb_queue_purge(&ap
->recv_queue
);
577 if (showcapimsgs
& 1) {
578 printk(KERN_DEBUG
"kcapi: appl %d down\n", ap
->applid
);
584 EXPORT_SYMBOL(capi20_release
);
586 u16
capi20_put_message(struct capi20_appl
*ap
, struct sk_buff
*skb
)
588 struct capi_ctr
*card
;
592 DBG("applid %#x", ap
->applid
);
595 return CAPI_REGNOTINSTALLED
;
596 if ((ap
->applid
== 0) || ap
->release_in_progress
)
597 return CAPI_ILLAPPNR
;
599 || !capi_cmd_valid(CAPIMSG_COMMAND(skb
->data
))
600 || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb
->data
)))
601 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL
;
602 card
= get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb
->data
));
603 if (!card
|| card
->cardstate
!= CARD_RUNNING
) {
604 card
= get_capi_ctr_by_nr(1); // XXX why?
605 if (!card
|| card
->cardstate
!= CARD_RUNNING
)
606 return CAPI_REGNOTINSTALLED
;
609 return CAPI_SENDQUEUEFULL
;
611 cmd
= CAPIMSG_COMMAND(skb
->data
);
612 subcmd
= CAPIMSG_SUBCOMMAND(skb
->data
);
614 if (cmd
== CAPI_DATA_B3
&& subcmd
== CAPI_REQ
) {
615 card
->nsentdatapkt
++;
617 if (card
->traceflag
> 2) showctl
|= 2;
621 if (card
->traceflag
) showctl
|= 2;
623 showctl
|= (card
->traceflag
& 1);
626 printk(KERN_DEBUG
"kcapi: put [%#x] id#%d %s len=%u\n",
627 CAPIMSG_CONTROLLER(skb
->data
),
628 CAPIMSG_APPID(skb
->data
),
629 capi_cmd2str(cmd
, subcmd
),
630 CAPIMSG_LEN(skb
->data
));
632 printk(KERN_DEBUG
"kcapi: put [%#x] %s\n",
633 CAPIMSG_CONTROLLER(skb
->data
),
634 capi_message2str(skb
->data
));
638 return card
->send_message(card
, skb
);
641 EXPORT_SYMBOL(capi20_put_message
);
643 u16
capi20_get_manufacturer(u32 contr
, u8
*buf
)
645 struct capi_ctr
*card
;
648 strlcpy(buf
, capi_manufakturer
, CAPI_MANUFACTURER_LEN
);
651 card
= get_capi_ctr_by_nr(contr
);
652 if (!card
|| card
->cardstate
!= CARD_RUNNING
)
653 return CAPI_REGNOTINSTALLED
;
654 strlcpy(buf
, card
->manu
, CAPI_MANUFACTURER_LEN
);
658 EXPORT_SYMBOL(capi20_get_manufacturer
);
660 u16
capi20_get_version(u32 contr
, struct capi_version
*verp
)
662 struct capi_ctr
*card
;
665 *verp
= driver_version
;
668 card
= get_capi_ctr_by_nr(contr
);
669 if (!card
|| card
->cardstate
!= CARD_RUNNING
)
670 return CAPI_REGNOTINSTALLED
;
672 memcpy((void *) verp
, &card
->version
, sizeof(capi_version
));
676 EXPORT_SYMBOL(capi20_get_version
);
678 u16
capi20_get_serial(u32 contr
, u8
*serial
)
680 struct capi_ctr
*card
;
683 strlcpy(serial
, driver_serial
, CAPI_SERIAL_LEN
);
686 card
= get_capi_ctr_by_nr(contr
);
687 if (!card
|| card
->cardstate
!= CARD_RUNNING
)
688 return CAPI_REGNOTINSTALLED
;
690 strlcpy((void *) serial
, card
->serial
, CAPI_SERIAL_LEN
);
694 EXPORT_SYMBOL(capi20_get_serial
);
696 u16
capi20_get_profile(u32 contr
, struct capi_profile
*profp
)
698 struct capi_ctr
*card
;
701 profp
->ncontroller
= ncards
;
704 card
= get_capi_ctr_by_nr(contr
);
705 if (!card
|| card
->cardstate
!= CARD_RUNNING
)
706 return CAPI_REGNOTINSTALLED
;
708 memcpy((void *) profp
, &card
->profile
,
709 sizeof(struct capi_profile
));
713 EXPORT_SYMBOL(capi20_get_profile
);
715 #ifdef CONFIG_AVMB1_COMPAT
716 static int old_capi_manufacturer(unsigned int cmd
, void __user
*data
)
718 avmb1_loadandconfigdef ldef
;
719 avmb1_extcarddef cdef
;
721 capicardparams cparams
;
722 struct capi_ctr
*card
;
723 struct capi_driver
*driver
= NULL
;
731 case AVMB1_ADDCARD_WITH_TYPE
:
732 if (cmd
== AVMB1_ADDCARD
) {
733 if ((retval
= copy_from_user(&cdef
, data
,
734 sizeof(avmb1_carddef
))))
736 cdef
.cardtype
= AVM_CARDTYPE_B1
;
738 if ((retval
= copy_from_user(&cdef
, data
,
739 sizeof(avmb1_extcarddef
))))
742 cparams
.port
= cdef
.port
;
743 cparams
.irq
= cdef
.irq
;
744 cparams
.cardnr
= cdef
.cardnr
;
746 read_lock_irqsave(&capi_drivers_list_lock
, flags
);
747 switch (cdef
.cardtype
) {
748 case AVM_CARDTYPE_B1
:
749 list_for_each(l
, &capi_drivers
) {
750 driver
= list_entry(l
, struct capi_driver
, list
);
751 if (strcmp(driver
->name
, "b1isa") == 0)
755 case AVM_CARDTYPE_T1
:
756 list_for_each(l
, &capi_drivers
) {
757 driver
= list_entry(l
, struct capi_driver
, list
);
758 if (strcmp(driver
->name
, "t1isa") == 0)
767 read_unlock_irqrestore(&capi_drivers_list_lock
, flags
);
768 printk(KERN_ERR
"kcapi: driver not loaded.\n");
771 if (!driver
->add_card
) {
772 read_unlock_irqrestore(&capi_drivers_list_lock
, flags
);
773 printk(KERN_ERR
"kcapi: driver has no add card function.\n");
777 retval
= driver
->add_card(driver
, &cparams
);
778 read_unlock_irqrestore(&capi_drivers_list_lock
, flags
);
782 case AVMB1_LOAD_AND_CONFIG
:
784 if (cmd
== AVMB1_LOAD
) {
785 if (copy_from_user(&ldef
, data
,
786 sizeof(avmb1_loaddef
)))
788 ldef
.t4config
.len
= 0;
789 ldef
.t4config
.data
= NULL
;
791 if (copy_from_user(&ldef
, data
,
792 sizeof(avmb1_loadandconfigdef
)))
795 card
= get_capi_ctr_by_nr(ldef
.contr
);
796 card
= capi_ctr_get(card
);
799 if (card
->load_firmware
== 0) {
800 printk(KERN_DEBUG
"kcapi: load: no load function\n");
804 if (ldef
.t4file
.len
<= 0) {
805 printk(KERN_DEBUG
"kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef
.t4file
.len
);
808 if (ldef
.t4file
.data
== 0) {
809 printk(KERN_DEBUG
"kcapi: load: invalid parameter: dataptr is 0\n");
813 ldata
.firmware
.user
= 1;
814 ldata
.firmware
.data
= ldef
.t4file
.data
;
815 ldata
.firmware
.len
= ldef
.t4file
.len
;
816 ldata
.configuration
.user
= 1;
817 ldata
.configuration
.data
= ldef
.t4config
.data
;
818 ldata
.configuration
.len
= ldef
.t4config
.len
;
820 if (card
->cardstate
!= CARD_DETECTED
) {
821 printk(KERN_INFO
"kcapi: load: contr=%d not in detect state\n", ldef
.contr
);
824 card
->cardstate
= CARD_LOADING
;
826 retval
= card
->load_firmware(card
, &ldata
);
829 card
->cardstate
= CARD_DETECTED
;
834 while (card
->cardstate
!= CARD_RUNNING
) {
836 msleep_interruptible(100); /* 0.1 sec */
838 if (signal_pending(current
)) {
846 case AVMB1_RESETCARD
:
847 if (copy_from_user(&rdef
, data
, sizeof(avmb1_resetdef
)))
849 card
= get_capi_ctr_by_nr(rdef
.contr
);
853 if (card
->cardstate
== CARD_DETECTED
)
856 card
->reset_ctr(card
);
858 while (card
->cardstate
> CARD_DETECTED
) {
860 msleep_interruptible(100); /* 0.1 sec */
862 if (signal_pending(current
))
872 int capi20_manufacturer(unsigned int cmd
, void __user
*data
)
874 struct capi_ctr
*card
;
877 #ifdef CONFIG_AVMB1_COMPAT
879 case AVMB1_LOAD_AND_CONFIG
:
880 case AVMB1_RESETCARD
:
881 case AVMB1_GET_CARDINFO
:
882 case AVMB1_REMOVECARD
:
883 return old_capi_manufacturer(cmd
, data
);
885 case KCAPI_CMD_TRACE
:
889 if (copy_from_user(&fdef
, data
, sizeof(kcapi_flagdef
)))
892 card
= get_capi_ctr_by_nr(fdef
.contr
);
896 card
->traceflag
= fdef
.flag
;
897 printk(KERN_INFO
"kcapi: contr %d set trace=%d\n",
898 card
->cnr
, card
->traceflag
);
901 case KCAPI_CMD_ADDCARD
:
904 struct capi_driver
*driver
= NULL
;
905 capicardparams cparams
;
909 if ((retval
= copy_from_user(&cdef
, data
, sizeof(cdef
))))
912 cparams
.port
= cdef
.port
;
913 cparams
.irq
= cdef
.irq
;
914 cparams
.membase
= cdef
.membase
;
915 cparams
.cardnr
= cdef
.cardnr
;
916 cparams
.cardtype
= 0;
917 cdef
.driver
[sizeof(cdef
.driver
)-1] = 0;
919 list_for_each(l
, &capi_drivers
) {
920 driver
= list_entry(l
, struct capi_driver
, list
);
921 if (strcmp(driver
->name
, cdef
.driver
) == 0)
925 printk(KERN_ERR
"kcapi: driver \"%s\" not loaded.\n",
930 if (!driver
->add_card
) {
931 printk(KERN_ERR
"kcapi: driver \"%s\" has no add card function.\n", cdef
.driver
);
935 return driver
->add_card(driver
, &cparams
);
939 printk(KERN_ERR
"kcapi: manufacturer command %d unknown.\n",
947 EXPORT_SYMBOL(capi20_manufacturer
);
950 void capi20_set_callback(struct capi20_appl
*ap
,
951 void (*callback
) (unsigned int cmd
, __u32 contr
, void *data
))
953 ap
->callback
= callback
;
956 EXPORT_SYMBOL(capi20_set_callback
);
958 /* ------------------------------------------------------------- */
959 /* -------- Init & Cleanup ------------------------------------- */
960 /* ------------------------------------------------------------- */
963 * init / exit functions
966 static int __init
kcapi_init(void)
973 if ((p
= strchr(revision
, ':')) != 0 && p
[1]) {
974 strlcpy(rev
, p
+ 2, sizeof(rev
));
975 if ((p
= strchr(rev
, '$')) != 0 && p
> rev
)
980 printk(KERN_NOTICE
"CAPI Subsystem Rev %s\n", rev
);
985 static void __exit
kcapi_exit(void)
989 /* make sure all notifiers are finished */
990 flush_scheduled_work();
993 module_init(kcapi_init
);
994 module_exit(kcapi_exit
);