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);