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.
16 #include <linux/module.h>
18 #include <linux/interrupt.h>
19 #include <linux/ioport.h>
20 #include <linux/proc_fs.h>
21 #include <linux/sched.h>
22 #include <linux/seq_file.h>
23 #include <linux/skbuff.h>
24 #include <linux/workqueue.h>
25 #include <linux/capi.h>
26 #include <linux/kernelcapi.h>
27 #include <linux/init.h>
28 #include <linux/moduleparam.h>
29 #include <linux/delay.h>
30 #include <asm/uaccess.h>
31 #include <linux/isdn/capicmd.h>
32 #include <linux/isdn/capiutil.h>
34 #include <linux/b1lli.h>
36 #include <linux/mutex.h>
38 static char *revision
= "$Revision: 1.1.2.8 $";
40 /* ------------------------------------------------------------- */
42 static int showcapimsgs
= 0;
44 MODULE_DESCRIPTION("CAPI4Linux: kernel CAPI layer");
45 MODULE_AUTHOR("Carsten Paeth");
46 MODULE_LICENSE("GPL");
47 module_param(showcapimsgs
, uint
, 0);
49 /* ------------------------------------------------------------- */
51 struct capi_notifier
{
52 struct work_struct work
;
59 /* ------------------------------------------------------------- */
61 static struct capi_version driver_version
= {2, 0, 1, 1<<4};
62 static char driver_serial
[CAPI_SERIAL_LEN
] = "0004711";
63 static char capi_manufakturer
[64] = "AVM Berlin";
65 #define NCCI2CTRL(ncci) (((ncci) >> 24) & 0x7f)
67 LIST_HEAD(capi_drivers
);
68 DEFINE_RWLOCK(capi_drivers_list_lock
);
70 static DEFINE_RWLOCK(application_lock
);
71 static DEFINE_MUTEX(controller_mutex
);
73 struct capi20_appl
*capi_applications
[CAPI_MAXAPPL
];
74 struct capi_ctr
*capi_cards
[CAPI_MAXCONTR
];
78 /* -------- controller ref counting -------------------------------------- */
80 static inline struct capi_ctr
*
81 capi_ctr_get(struct capi_ctr
*card
)
83 if (!try_module_get(card
->owner
))
89 capi_ctr_put(struct capi_ctr
*card
)
91 module_put(card
->owner
);
94 /* ------------------------------------------------------------- */
96 static inline struct capi_ctr
*get_capi_ctr_by_nr(u16 contr
)
98 if (contr
- 1 >= CAPI_MAXCONTR
)
101 return capi_cards
[contr
- 1];
104 static inline struct capi20_appl
*get_capi_appl_by_nr(u16 applid
)
106 if (applid
- 1 >= CAPI_MAXAPPL
)
109 return capi_applications
[applid
- 1];
112 /* -------- util functions ------------------------------------ */
114 static inline int capi_cmd_valid(u8 cmd
)
119 case CAPI_CONNECT_ACTIVE
:
120 case CAPI_CONNECT_B3_ACTIVE
:
121 case CAPI_CONNECT_B3
:
122 case CAPI_CONNECT_B3_T90_ACTIVE
:
124 case CAPI_DISCONNECT_B3
:
125 case CAPI_DISCONNECT
:
129 case CAPI_MANUFACTURER
:
131 case CAPI_SELECT_B_PROTOCOL
:
137 static inline int capi_subcmd_valid(u8 subcmd
)
149 /* ------------------------------------------------------------ */
151 static void register_appl(struct capi_ctr
*card
, u16 applid
, capi_register_params
*rparam
)
153 card
= capi_ctr_get(card
);
156 card
->register_appl(card
, applid
, rparam
);
158 printk(KERN_WARNING
"%s: cannot get card resources\n", __func__
);
162 static void release_appl(struct capi_ctr
*card
, u16 applid
)
164 DBG("applid %#x", applid
);
166 card
->release_appl(card
, applid
);
170 /* -------- KCI_CONTRUP --------------------------------------- */
172 static void notify_up(u32 contr
)
174 struct capi_ctr
*card
= get_capi_ctr_by_nr(contr
);
175 struct capi20_appl
*ap
;
178 if (showcapimsgs
& 1) {
179 printk(KERN_DEBUG
"kcapi: notify up contr %d\n", contr
);
182 printk(KERN_WARNING
"%s: invalid contr %d\n", __func__
, contr
);
185 for (applid
= 1; applid
<= CAPI_MAXAPPL
; applid
++) {
186 ap
= get_capi_appl_by_nr(applid
);
187 if (!ap
|| ap
->release_in_progress
) continue;
188 register_appl(card
, applid
, &ap
->rparam
);
189 if (ap
->callback
&& !ap
->release_in_progress
)
190 ap
->callback(KCI_CONTRUP
, contr
, &card
->profile
);
194 /* -------- KCI_CONTRDOWN ------------------------------------- */
196 static void notify_down(u32 contr
)
198 struct capi20_appl
*ap
;
201 if (showcapimsgs
& 1) {
202 printk(KERN_DEBUG
"kcapi: notify down contr %d\n", contr
);
205 for (applid
= 1; applid
<= CAPI_MAXAPPL
; applid
++) {
206 ap
= get_capi_appl_by_nr(applid
);
207 if (ap
&& ap
->callback
&& !ap
->release_in_progress
)
208 ap
->callback(KCI_CONTRDOWN
, contr
, NULL
);
212 static void notify_handler(struct work_struct
*work
)
214 struct capi_notifier
*np
=
215 container_of(work
, struct capi_notifier
, work
);
219 notify_up(np
->controller
);
222 notify_down(np
->controller
);
230 * The notifier will result in adding/deleteing of devices. Devices can
231 * only removed in user process, not in bh.
233 static int notify_push(unsigned int cmd
, u32 controller
, u16 applid
, u32 ncci
)
235 struct capi_notifier
*np
= kmalloc(sizeof(*np
), GFP_ATOMIC
);
240 INIT_WORK(&np
->work
, notify_handler
);
242 np
->controller
= controller
;
246 schedule_work(&np
->work
);
251 /* -------- Receiver ------------------------------------------ */
253 static void recv_handler(struct work_struct
*work
)
256 struct capi20_appl
*ap
=
257 container_of(work
, struct capi20_appl
, recv_work
);
259 if ((!ap
) || (ap
->release_in_progress
))
262 mutex_lock(&ap
->recv_mtx
);
263 while ((skb
= skb_dequeue(&ap
->recv_queue
))) {
264 if (CAPIMSG_CMD(skb
->data
) == CAPI_DATA_B3_IND
)
269 ap
->recv_message(ap
, skb
);
271 mutex_unlock(&ap
->recv_mtx
);
275 * capi_ctr_handle_message() - handle incoming CAPI message
276 * @card: controller descriptor structure.
277 * @appl: application ID.
280 * Called by hardware driver to pass a CAPI message to the application.
283 void capi_ctr_handle_message(struct capi_ctr
* card
, u16 appl
, struct sk_buff
*skb
)
285 struct capi20_appl
*ap
;
291 if (card
->cardstate
!= CARD_RUNNING
) {
292 cdb
= capi_message2str(skb
->data
);
294 printk(KERN_INFO
"kcapi: controller [%03d] not active, got: %s",
295 card
->cnr
, cdb
->buf
);
298 printk(KERN_INFO
"kcapi: controller [%03d] not active, cannot trace\n",
303 cmd
= CAPIMSG_COMMAND(skb
->data
);
304 subcmd
= CAPIMSG_SUBCOMMAND(skb
->data
);
305 if (cmd
== CAPI_DATA_B3
&& subcmd
== CAPI_IND
) {
306 card
->nrecvdatapkt
++;
307 if (card
->traceflag
> 2) showctl
|= 2;
310 if (card
->traceflag
) showctl
|= 2;
312 showctl
|= (card
->traceflag
& 1);
315 printk(KERN_DEBUG
"kcapi: got [%03d] id#%d %s len=%u\n",
316 card
->cnr
, CAPIMSG_APPID(skb
->data
),
317 capi_cmd2str(cmd
, subcmd
),
318 CAPIMSG_LEN(skb
->data
));
320 cdb
= capi_message2str(skb
->data
);
322 printk(KERN_DEBUG
"kcapi: got [%03d] %s\n",
323 card
->cnr
, cdb
->buf
);
326 printk(KERN_DEBUG
"kcapi: got [%03d] id#%d %s len=%u, cannot trace\n",
327 card
->cnr
, CAPIMSG_APPID(skb
->data
),
328 capi_cmd2str(cmd
, subcmd
),
329 CAPIMSG_LEN(skb
->data
));
334 read_lock_irqsave(&application_lock
, flags
);
335 ap
= get_capi_appl_by_nr(CAPIMSG_APPID(skb
->data
));
336 if ((!ap
) || (ap
->release_in_progress
)) {
337 read_unlock_irqrestore(&application_lock
, flags
);
338 cdb
= capi_message2str(skb
->data
);
340 printk(KERN_ERR
"kcapi: handle_message: applid %d state released (%s)\n",
341 CAPIMSG_APPID(skb
->data
), cdb
->buf
);
344 printk(KERN_ERR
"kcapi: handle_message: applid %d state released (%s) cannot trace\n",
345 CAPIMSG_APPID(skb
->data
),
346 capi_cmd2str(cmd
, subcmd
));
349 skb_queue_tail(&ap
->recv_queue
, skb
);
350 schedule_work(&ap
->recv_work
);
351 read_unlock_irqrestore(&application_lock
, flags
);
359 EXPORT_SYMBOL(capi_ctr_handle_message
);
362 * capi_ctr_ready() - signal CAPI controller ready
363 * @card: controller descriptor structure.
365 * Called by hardware driver to signal that the controller is up and running.
368 void capi_ctr_ready(struct capi_ctr
* card
)
370 card
->cardstate
= CARD_RUNNING
;
372 printk(KERN_NOTICE
"kcapi: card [%03d] \"%s\" ready.\n",
373 card
->cnr
, card
->name
);
375 notify_push(KCI_CONTRUP
, card
->cnr
, 0, 0);
378 EXPORT_SYMBOL(capi_ctr_ready
);
381 * capi_ctr_down() - signal CAPI controller not ready
382 * @card: controller descriptor structure.
384 * Called by hardware driver to signal that the controller is down and
385 * unavailable for use.
388 void capi_ctr_down(struct capi_ctr
* card
)
394 if (card
->cardstate
== CARD_DETECTED
)
397 card
->cardstate
= CARD_DETECTED
;
399 memset(card
->manu
, 0, sizeof(card
->manu
));
400 memset(&card
->version
, 0, sizeof(card
->version
));
401 memset(&card
->profile
, 0, sizeof(card
->profile
));
402 memset(card
->serial
, 0, sizeof(card
->serial
));
404 for (appl
= 1; appl
<= CAPI_MAXAPPL
; appl
++) {
405 struct capi20_appl
*ap
= get_capi_appl_by_nr(appl
);
406 if (!ap
|| ap
->release_in_progress
)
412 printk(KERN_NOTICE
"kcapi: card [%03d] down.\n", card
->cnr
);
414 notify_push(KCI_CONTRDOWN
, card
->cnr
, 0, 0);
417 EXPORT_SYMBOL(capi_ctr_down
);
420 * capi_ctr_suspend_output() - suspend controller
421 * @card: controller descriptor structure.
423 * Called by hardware driver to stop data flow.
426 void capi_ctr_suspend_output(struct capi_ctr
*card
)
428 if (!card
->blocked
) {
429 printk(KERN_DEBUG
"kcapi: card [%03d] suspend\n", card
->cnr
);
434 EXPORT_SYMBOL(capi_ctr_suspend_output
);
437 * capi_ctr_resume_output() - resume controller
438 * @card: controller descriptor structure.
440 * Called by hardware driver to resume data flow.
443 void capi_ctr_resume_output(struct capi_ctr
*card
)
446 printk(KERN_DEBUG
"kcapi: card [%03d] resume\n", card
->cnr
);
451 EXPORT_SYMBOL(capi_ctr_resume_output
);
453 /* ------------------------------------------------------------- */
456 * attach_capi_ctr() - register CAPI controller
457 * @card: controller descriptor structure.
459 * Called by hardware driver to register a controller with the CAPI subsystem.
460 * Return value: 0 on success, error code < 0 on error
464 attach_capi_ctr(struct capi_ctr
*card
)
468 mutex_lock(&controller_mutex
);
470 for (i
= 0; i
< CAPI_MAXCONTR
; i
++) {
471 if (capi_cards
[i
] == NULL
)
474 if (i
== CAPI_MAXCONTR
) {
475 mutex_unlock(&controller_mutex
);
476 printk(KERN_ERR
"kcapi: out of controller slots\n");
479 capi_cards
[i
] = card
;
481 mutex_unlock(&controller_mutex
);
483 card
->nrecvctlpkt
= 0;
484 card
->nrecvdatapkt
= 0;
485 card
->nsentctlpkt
= 0;
486 card
->nsentdatapkt
= 0;
488 card
->cardstate
= CARD_DETECTED
;
490 card
->traceflag
= showcapimsgs
;
492 sprintf(card
->procfn
, "capi/controllers/%d", card
->cnr
);
493 card
->procent
= proc_create_data(card
->procfn
, 0, NULL
, card
->proc_fops
, card
);
496 printk(KERN_NOTICE
"kcapi: Controller [%03d]: %s attached\n",
497 card
->cnr
, card
->name
);
501 EXPORT_SYMBOL(attach_capi_ctr
);
504 * detach_capi_ctr() - unregister CAPI controller
505 * @card: controller descriptor structure.
507 * Called by hardware driver to remove the registration of a controller
508 * with the CAPI subsystem.
509 * Return value: 0 on success, error code < 0 on error
512 int detach_capi_ctr(struct capi_ctr
*card
)
514 if (card
->cardstate
!= CARD_DETECTED
)
520 remove_proc_entry(card
->procfn
, NULL
);
521 card
->procent
= NULL
;
523 capi_cards
[card
->cnr
- 1] = NULL
;
524 printk(KERN_NOTICE
"kcapi: Controller [%03d]: %s unregistered\n",
525 card
->cnr
, card
->name
);
530 EXPORT_SYMBOL(detach_capi_ctr
);
533 * register_capi_driver() - register CAPI driver
534 * @driver: driver descriptor structure.
536 * Called by hardware driver to register itself with the CAPI subsystem.
539 void register_capi_driver(struct capi_driver
*driver
)
543 write_lock_irqsave(&capi_drivers_list_lock
, flags
);
544 list_add_tail(&driver
->list
, &capi_drivers
);
545 write_unlock_irqrestore(&capi_drivers_list_lock
, flags
);
548 EXPORT_SYMBOL(register_capi_driver
);
551 * unregister_capi_driver() - unregister CAPI driver
552 * @driver: driver descriptor structure.
554 * Called by hardware driver to unregister itself from the CAPI subsystem.
557 void unregister_capi_driver(struct capi_driver
*driver
)
561 write_lock_irqsave(&capi_drivers_list_lock
, flags
);
562 list_del(&driver
->list
);
563 write_unlock_irqrestore(&capi_drivers_list_lock
, flags
);
566 EXPORT_SYMBOL(unregister_capi_driver
);
568 /* ------------------------------------------------------------- */
569 /* -------- CAPI2.0 Interface ---------------------------------- */
570 /* ------------------------------------------------------------- */
573 * capi20_isinstalled() - CAPI 2.0 operation CAPI_INSTALLED
575 * Return value: CAPI result code (CAPI_NOERROR if at least one ISDN controller
576 * is ready for use, CAPI_REGNOTINSTALLED otherwise)
579 u16
capi20_isinstalled(void)
582 for (i
= 0; i
< CAPI_MAXCONTR
; i
++) {
583 if (capi_cards
[i
] && capi_cards
[i
]->cardstate
== CARD_RUNNING
)
586 return CAPI_REGNOTINSTALLED
;
589 EXPORT_SYMBOL(capi20_isinstalled
);
592 * capi20_register() - CAPI 2.0 operation CAPI_REGISTER
593 * @ap: CAPI application descriptor structure.
595 * Register an application's presence with CAPI.
596 * A unique application ID is assigned and stored in @ap->applid.
597 * After this function returns successfully, the message receive
598 * callback function @ap->recv_message() may be called at any time
599 * until capi20_release() has been called for the same @ap.
600 * Return value: CAPI result code
603 u16
capi20_register(struct capi20_appl
*ap
)
611 if (ap
->rparam
.datablklen
< 128)
612 return CAPI_LOGBLKSIZETOSMALL
;
614 write_lock_irqsave(&application_lock
, flags
);
616 for (applid
= 1; applid
<= CAPI_MAXAPPL
; applid
++) {
617 if (capi_applications
[applid
- 1] == NULL
)
620 if (applid
> CAPI_MAXAPPL
) {
621 write_unlock_irqrestore(&application_lock
, flags
);
622 return CAPI_TOOMANYAPPLS
;
626 capi_applications
[applid
- 1] = ap
;
629 ap
->nrecvdatapkt
= 0;
631 ap
->nsentdatapkt
= 0;
633 mutex_init(&ap
->recv_mtx
);
634 skb_queue_head_init(&ap
->recv_queue
);
635 INIT_WORK(&ap
->recv_work
, recv_handler
);
636 ap
->release_in_progress
= 0;
638 write_unlock_irqrestore(&application_lock
, flags
);
640 mutex_lock(&controller_mutex
);
641 for (i
= 0; i
< CAPI_MAXCONTR
; i
++) {
642 if (!capi_cards
[i
] || capi_cards
[i
]->cardstate
!= CARD_RUNNING
)
644 register_appl(capi_cards
[i
], applid
, &ap
->rparam
);
646 mutex_unlock(&controller_mutex
);
648 if (showcapimsgs
& 1) {
649 printk(KERN_DEBUG
"kcapi: appl %d up\n", applid
);
655 EXPORT_SYMBOL(capi20_register
);
658 * capi20_release() - CAPI 2.0 operation CAPI_RELEASE
659 * @ap: CAPI application descriptor structure.
661 * Terminate an application's registration with CAPI.
662 * After this function returns successfully, the message receive
663 * callback function @ap->recv_message() will no longer be called.
664 * Return value: CAPI result code
667 u16
capi20_release(struct capi20_appl
*ap
)
672 DBG("applid %#x", ap
->applid
);
674 write_lock_irqsave(&application_lock
, flags
);
675 ap
->release_in_progress
= 1;
676 capi_applications
[ap
->applid
- 1] = NULL
;
677 write_unlock_irqrestore(&application_lock
, flags
);
679 mutex_lock(&controller_mutex
);
680 for (i
= 0; i
< CAPI_MAXCONTR
; i
++) {
681 if (!capi_cards
[i
] || capi_cards
[i
]->cardstate
!= CARD_RUNNING
)
683 release_appl(capi_cards
[i
], ap
->applid
);
685 mutex_unlock(&controller_mutex
);
687 flush_scheduled_work();
688 skb_queue_purge(&ap
->recv_queue
);
690 if (showcapimsgs
& 1) {
691 printk(KERN_DEBUG
"kcapi: appl %d down\n", ap
->applid
);
697 EXPORT_SYMBOL(capi20_release
);
700 * capi20_put_message() - CAPI 2.0 operation CAPI_PUT_MESSAGE
701 * @ap: CAPI application descriptor structure.
702 * @skb: CAPI message.
704 * Transfer a single message to CAPI.
705 * Return value: CAPI result code
708 u16
capi20_put_message(struct capi20_appl
*ap
, struct sk_buff
*skb
)
710 struct capi_ctr
*card
;
714 DBG("applid %#x", ap
->applid
);
717 return CAPI_REGNOTINSTALLED
;
718 if ((ap
->applid
== 0) || ap
->release_in_progress
)
719 return CAPI_ILLAPPNR
;
721 || !capi_cmd_valid(CAPIMSG_COMMAND(skb
->data
))
722 || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb
->data
)))
723 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL
;
724 card
= get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb
->data
));
725 if (!card
|| card
->cardstate
!= CARD_RUNNING
) {
726 card
= get_capi_ctr_by_nr(1); // XXX why?
727 if (!card
|| card
->cardstate
!= CARD_RUNNING
)
728 return CAPI_REGNOTINSTALLED
;
731 return CAPI_SENDQUEUEFULL
;
733 cmd
= CAPIMSG_COMMAND(skb
->data
);
734 subcmd
= CAPIMSG_SUBCOMMAND(skb
->data
);
736 if (cmd
== CAPI_DATA_B3
&& subcmd
== CAPI_REQ
) {
737 card
->nsentdatapkt
++;
739 if (card
->traceflag
> 2) showctl
|= 2;
743 if (card
->traceflag
) showctl
|= 2;
745 showctl
|= (card
->traceflag
& 1);
748 printk(KERN_DEBUG
"kcapi: put [%03d] id#%d %s len=%u\n",
749 CAPIMSG_CONTROLLER(skb
->data
),
750 CAPIMSG_APPID(skb
->data
),
751 capi_cmd2str(cmd
, subcmd
),
752 CAPIMSG_LEN(skb
->data
));
754 _cdebbuf
*cdb
= capi_message2str(skb
->data
);
756 printk(KERN_DEBUG
"kcapi: put [%03d] %s\n",
757 CAPIMSG_CONTROLLER(skb
->data
),
761 printk(KERN_DEBUG
"kcapi: put [%03d] id#%d %s len=%u cannot trace\n",
762 CAPIMSG_CONTROLLER(skb
->data
),
763 CAPIMSG_APPID(skb
->data
),
764 capi_cmd2str(cmd
, subcmd
),
765 CAPIMSG_LEN(skb
->data
));
768 return card
->send_message(card
, skb
);
771 EXPORT_SYMBOL(capi20_put_message
);
774 * capi20_get_manufacturer() - CAPI 2.0 operation CAPI_GET_MANUFACTURER
775 * @contr: controller number.
776 * @buf: result buffer (64 bytes).
778 * Retrieve information about the manufacturer of the specified ISDN controller
779 * or (for @contr == 0) the driver itself.
780 * Return value: CAPI result code
783 u16
capi20_get_manufacturer(u32 contr
, u8
*buf
)
785 struct capi_ctr
*card
;
788 strlcpy(buf
, capi_manufakturer
, CAPI_MANUFACTURER_LEN
);
791 card
= get_capi_ctr_by_nr(contr
);
792 if (!card
|| card
->cardstate
!= CARD_RUNNING
)
793 return CAPI_REGNOTINSTALLED
;
794 strlcpy(buf
, card
->manu
, CAPI_MANUFACTURER_LEN
);
798 EXPORT_SYMBOL(capi20_get_manufacturer
);
801 * capi20_get_version() - CAPI 2.0 operation CAPI_GET_VERSION
802 * @contr: controller number.
803 * @verp: result structure.
805 * Retrieve version information for the specified ISDN controller
806 * or (for @contr == 0) the driver itself.
807 * Return value: CAPI result code
810 u16
capi20_get_version(u32 contr
, struct capi_version
*verp
)
812 struct capi_ctr
*card
;
815 *verp
= driver_version
;
818 card
= get_capi_ctr_by_nr(contr
);
819 if (!card
|| card
->cardstate
!= CARD_RUNNING
)
820 return CAPI_REGNOTINSTALLED
;
822 memcpy((void *) verp
, &card
->version
, sizeof(capi_version
));
826 EXPORT_SYMBOL(capi20_get_version
);
829 * capi20_get_serial() - CAPI 2.0 operation CAPI_GET_SERIAL_NUMBER
830 * @contr: controller number.
831 * @serial: result buffer (8 bytes).
833 * Retrieve the serial number of the specified ISDN controller
834 * or (for @contr == 0) the driver itself.
835 * Return value: CAPI result code
838 u16
capi20_get_serial(u32 contr
, u8
*serial
)
840 struct capi_ctr
*card
;
843 strlcpy(serial
, driver_serial
, CAPI_SERIAL_LEN
);
846 card
= get_capi_ctr_by_nr(contr
);
847 if (!card
|| card
->cardstate
!= CARD_RUNNING
)
848 return CAPI_REGNOTINSTALLED
;
850 strlcpy((void *) serial
, card
->serial
, CAPI_SERIAL_LEN
);
854 EXPORT_SYMBOL(capi20_get_serial
);
857 * capi20_get_profile() - CAPI 2.0 operation CAPI_GET_PROFILE
858 * @contr: controller number.
859 * @profp: result structure.
861 * Retrieve capability information for the specified ISDN controller
862 * or (for @contr == 0) the number of installed controllers.
863 * Return value: CAPI result code
866 u16
capi20_get_profile(u32 contr
, struct capi_profile
*profp
)
868 struct capi_ctr
*card
;
871 profp
->ncontroller
= ncards
;
874 card
= get_capi_ctr_by_nr(contr
);
875 if (!card
|| card
->cardstate
!= CARD_RUNNING
)
876 return CAPI_REGNOTINSTALLED
;
878 memcpy((void *) profp
, &card
->profile
,
879 sizeof(struct capi_profile
));
883 EXPORT_SYMBOL(capi20_get_profile
);
886 static int old_capi_manufacturer(unsigned int cmd
, void __user
*data
)
888 avmb1_loadandconfigdef ldef
;
889 avmb1_extcarddef cdef
;
891 capicardparams cparams
;
892 struct capi_ctr
*card
;
893 struct capi_driver
*driver
= NULL
;
901 case AVMB1_ADDCARD_WITH_TYPE
:
902 if (cmd
== AVMB1_ADDCARD
) {
903 if ((retval
= copy_from_user(&cdef
, data
,
904 sizeof(avmb1_carddef
))))
906 cdef
.cardtype
= AVM_CARDTYPE_B1
;
908 if ((retval
= copy_from_user(&cdef
, data
,
909 sizeof(avmb1_extcarddef
))))
912 cparams
.port
= cdef
.port
;
913 cparams
.irq
= cdef
.irq
;
914 cparams
.cardnr
= cdef
.cardnr
;
916 read_lock_irqsave(&capi_drivers_list_lock
, flags
);
917 switch (cdef
.cardtype
) {
918 case AVM_CARDTYPE_B1
:
919 list_for_each(l
, &capi_drivers
) {
920 driver
= list_entry(l
, struct capi_driver
, list
);
921 if (strcmp(driver
->name
, "b1isa") == 0)
925 case AVM_CARDTYPE_T1
:
926 list_for_each(l
, &capi_drivers
) {
927 driver
= list_entry(l
, struct capi_driver
, list
);
928 if (strcmp(driver
->name
, "t1isa") == 0)
937 read_unlock_irqrestore(&capi_drivers_list_lock
, flags
);
938 printk(KERN_ERR
"kcapi: driver not loaded.\n");
941 if (!driver
->add_card
) {
942 read_unlock_irqrestore(&capi_drivers_list_lock
, flags
);
943 printk(KERN_ERR
"kcapi: driver has no add card function.\n");
947 retval
= driver
->add_card(driver
, &cparams
);
948 read_unlock_irqrestore(&capi_drivers_list_lock
, flags
);
952 case AVMB1_LOAD_AND_CONFIG
:
954 if (cmd
== AVMB1_LOAD
) {
955 if (copy_from_user(&ldef
, data
,
956 sizeof(avmb1_loaddef
)))
958 ldef
.t4config
.len
= 0;
959 ldef
.t4config
.data
= NULL
;
961 if (copy_from_user(&ldef
, data
,
962 sizeof(avmb1_loadandconfigdef
)))
965 card
= get_capi_ctr_by_nr(ldef
.contr
);
968 card
= capi_ctr_get(card
);
971 if (card
->load_firmware
== NULL
) {
972 printk(KERN_DEBUG
"kcapi: load: no load function\n");
977 if (ldef
.t4file
.len
<= 0) {
978 printk(KERN_DEBUG
"kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef
.t4file
.len
);
982 if (ldef
.t4file
.data
== NULL
) {
983 printk(KERN_DEBUG
"kcapi: load: invalid parameter: dataptr is 0\n");
988 ldata
.firmware
.user
= 1;
989 ldata
.firmware
.data
= ldef
.t4file
.data
;
990 ldata
.firmware
.len
= ldef
.t4file
.len
;
991 ldata
.configuration
.user
= 1;
992 ldata
.configuration
.data
= ldef
.t4config
.data
;
993 ldata
.configuration
.len
= ldef
.t4config
.len
;
995 if (card
->cardstate
!= CARD_DETECTED
) {
996 printk(KERN_INFO
"kcapi: load: contr=%d not in detect state\n", ldef
.contr
);
1000 card
->cardstate
= CARD_LOADING
;
1002 retval
= card
->load_firmware(card
, &ldata
);
1005 card
->cardstate
= CARD_DETECTED
;
1010 while (card
->cardstate
!= CARD_RUNNING
) {
1012 msleep_interruptible(100); /* 0.1 sec */
1014 if (signal_pending(current
)) {
1022 case AVMB1_RESETCARD
:
1023 if (copy_from_user(&rdef
, data
, sizeof(avmb1_resetdef
)))
1025 card
= get_capi_ctr_by_nr(rdef
.contr
);
1029 if (card
->cardstate
== CARD_DETECTED
)
1032 card
->reset_ctr(card
);
1034 while (card
->cardstate
> CARD_DETECTED
) {
1036 msleep_interruptible(100); /* 0.1 sec */
1038 if (signal_pending(current
))
1049 * capi20_manufacturer() - CAPI 2.0 operation CAPI_MANUFACTURER
1053 * Perform manufacturer specific command.
1054 * Return value: CAPI result code
1057 int capi20_manufacturer(unsigned int cmd
, void __user
*data
)
1059 struct capi_ctr
*card
;
1064 case AVMB1_LOAD_AND_CONFIG
:
1065 case AVMB1_RESETCARD
:
1066 case AVMB1_GET_CARDINFO
:
1067 case AVMB1_REMOVECARD
:
1068 return old_capi_manufacturer(cmd
, data
);
1070 case KCAPI_CMD_TRACE
:
1074 if (copy_from_user(&fdef
, data
, sizeof(kcapi_flagdef
)))
1077 card
= get_capi_ctr_by_nr(fdef
.contr
);
1081 card
->traceflag
= fdef
.flag
;
1082 printk(KERN_INFO
"kcapi: contr [%03d] set trace=%d\n",
1083 card
->cnr
, card
->traceflag
);
1086 case KCAPI_CMD_ADDCARD
:
1088 struct list_head
*l
;
1089 struct capi_driver
*driver
= NULL
;
1090 capicardparams cparams
;
1094 if ((retval
= copy_from_user(&cdef
, data
, sizeof(cdef
))))
1097 cparams
.port
= cdef
.port
;
1098 cparams
.irq
= cdef
.irq
;
1099 cparams
.membase
= cdef
.membase
;
1100 cparams
.cardnr
= cdef
.cardnr
;
1101 cparams
.cardtype
= 0;
1102 cdef
.driver
[sizeof(cdef
.driver
)-1] = 0;
1104 list_for_each(l
, &capi_drivers
) {
1105 driver
= list_entry(l
, struct capi_driver
, list
);
1106 if (strcmp(driver
->name
, cdef
.driver
) == 0)
1109 if (driver
== NULL
) {
1110 printk(KERN_ERR
"kcapi: driver \"%s\" not loaded.\n",
1115 if (!driver
->add_card
) {
1116 printk(KERN_ERR
"kcapi: driver \"%s\" has no add card function.\n", cdef
.driver
);
1120 return driver
->add_card(driver
, &cparams
);
1124 printk(KERN_ERR
"kcapi: manufacturer command %d unknown.\n",
1132 EXPORT_SYMBOL(capi20_manufacturer
);
1134 /* temporary hack */
1137 * capi20_set_callback() - set CAPI application notification callback function
1138 * @ap: CAPI application descriptor structure.
1139 * @callback: callback function (NULL to remove).
1141 * If not NULL, the callback function will be called to notify the
1142 * application of the addition or removal of a controller.
1143 * The first argument (cmd) will tell whether the controller was added
1144 * (KCI_CONTRUP) or removed (KCI_CONTRDOWN).
1145 * The second argument (contr) will be the controller number.
1146 * For cmd==KCI_CONTRUP the third argument (data) will be a pointer to the
1147 * new controller's capability profile structure.
1150 void capi20_set_callback(struct capi20_appl
*ap
,
1151 void (*callback
) (unsigned int cmd
, __u32 contr
, void *data
))
1153 ap
->callback
= callback
;
1156 EXPORT_SYMBOL(capi20_set_callback
);
1158 /* ------------------------------------------------------------- */
1159 /* -------- Init & Cleanup ------------------------------------- */
1160 /* ------------------------------------------------------------- */
1163 * init / exit functions
1166 static int __init
kcapi_init(void)
1172 ret
= cdebug_init();
1177 if ((p
= strchr(revision
, ':')) != NULL
&& p
[1]) {
1178 strlcpy(rev
, p
+ 2, sizeof(rev
));
1179 if ((p
= strchr(rev
, '$')) != NULL
&& p
> rev
)
1184 printk(KERN_NOTICE
"CAPI Subsystem Rev %s\n", rev
);
1189 static void __exit
kcapi_exit(void)
1193 /* make sure all notifiers are finished */
1194 flush_scheduled_work();
1198 module_init(kcapi_init
);
1199 module_exit(kcapi_exit
);