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 int showcapimsgs = 0;
40 MODULE_DESCRIPTION("CAPI4Linux: kernel CAPI layer");
41 MODULE_AUTHOR("Carsten Paeth");
42 MODULE_LICENSE("GPL");
43 module_param(showcapimsgs, uint, 0);
45 /* ------------------------------------------------------------- */
47 struct capictr_event {
48 struct work_struct work;
53 /* ------------------------------------------------------------- */
55 static struct capi_version driver_version = {2, 0, 1, 1<<4};
56 static char driver_serial[CAPI_SERIAL_LEN] = "0004711";
57 static char capi_manufakturer[64] = "AVM Berlin";
59 #define NCCI2CTRL(ncci) (((ncci) >> 24) & 0x7f)
61 LIST_HEAD(capi_drivers);
62 DEFINE_MUTEX(capi_drivers_lock);
64 struct capi_ctr *capi_controller[CAPI_MAXCONTR];
65 DEFINE_MUTEX(capi_controller_lock);
67 static DEFINE_RWLOCK(application_lock);
69 struct capi20_appl *capi_applications[CAPI_MAXAPPL];
71 static int ncontrollers;
73 static BLOCKING_NOTIFIER_HEAD(ctr_notifier_list);
75 /* -------- controller ref counting -------------------------------------- */
77 static inline struct capi_ctr *
78 capi_ctr_get(struct capi_ctr *ctr)
80 if (!try_module_get(ctr->owner))
86 capi_ctr_put(struct capi_ctr *ctr)
88 module_put(ctr->owner);
91 /* ------------------------------------------------------------- */
93 static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr)
95 if (contr - 1 >= CAPI_MAXCONTR)
98 return capi_controller[contr - 1];
101 static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid)
103 if (applid - 1 >= CAPI_MAXAPPL)
106 return capi_applications[applid - 1];
109 /* -------- util functions ------------------------------------ */
111 static inline int capi_cmd_valid(u8 cmd)
116 case CAPI_CONNECT_ACTIVE:
117 case CAPI_CONNECT_B3_ACTIVE:
118 case CAPI_CONNECT_B3:
119 case CAPI_CONNECT_B3_T90_ACTIVE:
121 case CAPI_DISCONNECT_B3:
122 case CAPI_DISCONNECT:
126 case CAPI_MANUFACTURER:
128 case CAPI_SELECT_B_PROTOCOL:
134 static inline int capi_subcmd_valid(u8 subcmd)
146 /* ------------------------------------------------------------ */
149 register_appl(struct capi_ctr *ctr, u16 applid, capi_register_params *rparam)
151 ctr = capi_ctr_get(ctr);
154 ctr->register_appl(ctr, applid, rparam);
156 printk(KERN_WARNING "%s: cannot get controller resources\n",
161 static void release_appl(struct capi_ctr *ctr, u16 applid)
163 DBG("applid %#x", applid);
165 ctr->release_appl(ctr, applid);
169 static void notify_up(u32 contr)
171 struct capi20_appl *ap;
172 struct capi_ctr *ctr;
175 mutex_lock(&capi_controller_lock);
177 if (showcapimsgs & 1)
178 printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr);
180 ctr = get_capi_ctr_by_nr(contr);
182 if (ctr->state == CAPI_CTR_RUNNING)
185 ctr->state = CAPI_CTR_RUNNING;
187 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
188 ap = get_capi_appl_by_nr(applid);
189 if (!ap || ap->release_in_progress)
191 register_appl(ctr, applid, &ap->rparam);
194 wake_up_interruptible_all(&ctr->state_wait_queue);
196 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
199 mutex_unlock(&capi_controller_lock);
202 static void ctr_down(struct capi_ctr *ctr, int new_state)
204 struct capi20_appl *ap;
207 if (ctr->state == CAPI_CTR_DETECTED || ctr->state == CAPI_CTR_DETACHED)
210 ctr->state = new_state;
212 memset(ctr->manu, 0, sizeof(ctr->manu));
213 memset(&ctr->version, 0, sizeof(ctr->version));
214 memset(&ctr->profile, 0, sizeof(ctr->profile));
215 memset(ctr->serial, 0, sizeof(ctr->serial));
217 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
218 ap = get_capi_appl_by_nr(applid);
219 if (ap && !ap->release_in_progress)
223 wake_up_interruptible_all(&ctr->state_wait_queue);
226 static void notify_down(u32 contr)
228 struct capi_ctr *ctr;
230 mutex_lock(&capi_controller_lock);
232 if (showcapimsgs & 1)
233 printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr);
235 ctr = get_capi_ctr_by_nr(contr);
237 ctr_down(ctr, CAPI_CTR_DETECTED);
239 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
241 mutex_unlock(&capi_controller_lock);
245 notify_handler(struct notifier_block *nb, unsigned long val, void *v)
260 static void do_notify_work(struct work_struct *work)
262 struct capictr_event *event =
263 container_of(work, struct capictr_event, work);
265 blocking_notifier_call_chain(&ctr_notifier_list, event->type,
266 (void *)(long)event->controller);
271 * The notifier will result in adding/deleteing of devices. Devices can
272 * only removed in user process, not in bh.
274 static int notify_push(unsigned int event_type, u32 controller)
276 struct capictr_event *event = kmalloc(sizeof(*event), GFP_ATOMIC);
281 INIT_WORK(&event->work, do_notify_work);
282 event->type = event_type;
283 event->controller = controller;
285 schedule_work(&event->work);
289 int register_capictr_notifier(struct notifier_block *nb)
291 return blocking_notifier_chain_register(&ctr_notifier_list, nb);
293 EXPORT_SYMBOL_GPL(register_capictr_notifier);
295 int unregister_capictr_notifier(struct notifier_block *nb)
297 return blocking_notifier_chain_unregister(&ctr_notifier_list, nb);
299 EXPORT_SYMBOL_GPL(unregister_capictr_notifier);
301 /* -------- Receiver ------------------------------------------ */
303 static void recv_handler(struct work_struct *work)
306 struct capi20_appl *ap =
307 container_of(work, struct capi20_appl, recv_work);
309 if ((!ap) || (ap->release_in_progress))
312 mutex_lock(&ap->recv_mtx);
313 while ((skb = skb_dequeue(&ap->recv_queue))) {
314 if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND)
319 ap->recv_message(ap, skb);
321 mutex_unlock(&ap->recv_mtx);
325 * capi_ctr_handle_message() - handle incoming CAPI message
326 * @ctr: controller descriptor structure.
327 * @appl: application ID.
330 * Called by hardware driver to pass a CAPI message to the application.
333 void capi_ctr_handle_message(struct capi_ctr *ctr, u16 appl,
336 struct capi20_appl *ap;
342 if (ctr->state != CAPI_CTR_RUNNING) {
343 cdb = capi_message2str(skb->data);
345 printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s",
349 printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n",
354 cmd = CAPIMSG_COMMAND(skb->data);
355 subcmd = CAPIMSG_SUBCOMMAND(skb->data);
356 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {
358 if (ctr->traceflag > 2)
365 showctl |= (ctr->traceflag & 1);
368 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n",
369 ctr->cnr, CAPIMSG_APPID(skb->data),
370 capi_cmd2str(cmd, subcmd),
371 CAPIMSG_LEN(skb->data));
373 cdb = capi_message2str(skb->data);
375 printk(KERN_DEBUG "kcapi: got [%03d] %s\n",
379 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n",
380 ctr->cnr, CAPIMSG_APPID(skb->data),
381 capi_cmd2str(cmd, subcmd),
382 CAPIMSG_LEN(skb->data));
387 read_lock_irqsave(&application_lock, flags);
388 ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data));
389 if ((!ap) || (ap->release_in_progress)) {
390 read_unlock_irqrestore(&application_lock, flags);
391 cdb = capi_message2str(skb->data);
393 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n",
394 CAPIMSG_APPID(skb->data), cdb->buf);
397 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s) cannot trace\n",
398 CAPIMSG_APPID(skb->data),
399 capi_cmd2str(cmd, subcmd));
402 skb_queue_tail(&ap->recv_queue, skb);
403 schedule_work(&ap->recv_work);
404 read_unlock_irqrestore(&application_lock, flags);
412 EXPORT_SYMBOL(capi_ctr_handle_message);
415 * capi_ctr_ready() - signal CAPI controller ready
416 * @ctr: controller descriptor structure.
418 * Called by hardware driver to signal that the controller is up and running.
421 void capi_ctr_ready(struct capi_ctr *ctr)
423 printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n",
424 ctr->cnr, ctr->name);
426 notify_push(CAPICTR_UP, ctr->cnr);
429 EXPORT_SYMBOL(capi_ctr_ready);
432 * capi_ctr_down() - signal CAPI controller not ready
433 * @ctr: controller descriptor structure.
435 * Called by hardware driver to signal that the controller is down and
436 * unavailable for use.
439 void capi_ctr_down(struct capi_ctr *ctr)
441 printk(KERN_NOTICE "kcapi: controller [%03d] down.\n", ctr->cnr);
443 notify_push(CAPICTR_DOWN, ctr->cnr);
446 EXPORT_SYMBOL(capi_ctr_down);
449 * capi_ctr_suspend_output() - suspend controller
450 * @ctr: controller descriptor structure.
452 * Called by hardware driver to stop data flow.
454 * Note: The caller is responsible for synchronizing concurrent state changes
455 * as well as invocations of capi_ctr_handle_message.
458 void capi_ctr_suspend_output(struct capi_ctr *ctr)
461 printk(KERN_DEBUG "kcapi: controller [%03d] suspend\n",
467 EXPORT_SYMBOL(capi_ctr_suspend_output);
470 * capi_ctr_resume_output() - resume controller
471 * @ctr: controller descriptor structure.
473 * Called by hardware driver to resume data flow.
475 * Note: The caller is responsible for synchronizing concurrent state changes
476 * as well as invocations of capi_ctr_handle_message.
479 void capi_ctr_resume_output(struct capi_ctr *ctr)
482 printk(KERN_DEBUG "kcapi: controller [%03d] resumed\n",
488 EXPORT_SYMBOL(capi_ctr_resume_output);
490 /* ------------------------------------------------------------- */
493 * attach_capi_ctr() - register CAPI controller
494 * @ctr: controller descriptor structure.
496 * Called by hardware driver to register a controller with the CAPI subsystem.
497 * Return value: 0 on success, error code < 0 on error
500 int attach_capi_ctr(struct capi_ctr *ctr)
504 mutex_lock(&capi_controller_lock);
506 for (i = 0; i < CAPI_MAXCONTR; i++) {
507 if (!capi_controller[i])
510 if (i == CAPI_MAXCONTR) {
511 mutex_unlock(&capi_controller_lock);
512 printk(KERN_ERR "kcapi: out of controller slots\n");
515 capi_controller[i] = ctr;
517 ctr->nrecvctlpkt = 0;
518 ctr->nrecvdatapkt = 0;
519 ctr->nsentctlpkt = 0;
520 ctr->nsentdatapkt = 0;
522 ctr->state = CAPI_CTR_DETECTED;
524 ctr->traceflag = showcapimsgs;
525 init_waitqueue_head(&ctr->state_wait_queue);
527 sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr);
528 ctr->procent = proc_create_data(ctr->procfn, 0, NULL, ctr->proc_fops, ctr);
532 mutex_unlock(&capi_controller_lock);
534 printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n",
535 ctr->cnr, ctr->name);
539 EXPORT_SYMBOL(attach_capi_ctr);
542 * detach_capi_ctr() - unregister CAPI controller
543 * @ctr: controller descriptor structure.
545 * Called by hardware driver to remove the registration of a controller
546 * with the CAPI subsystem.
547 * Return value: 0 on success, error code < 0 on error
550 int detach_capi_ctr(struct capi_ctr *ctr)
554 mutex_lock(&capi_controller_lock);
556 ctr_down(ctr, CAPI_CTR_DETACHED);
558 if (capi_controller[ctr->cnr - 1] != ctr) {
562 capi_controller[ctr->cnr - 1] = NULL;
566 remove_proc_entry(ctr->procfn, NULL);
568 printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n",
569 ctr->cnr, ctr->name);
572 mutex_unlock(&capi_controller_lock);
577 EXPORT_SYMBOL(detach_capi_ctr);
580 * register_capi_driver() - register CAPI driver
581 * @driver: driver descriptor structure.
583 * Called by hardware driver to register itself with the CAPI subsystem.
586 void register_capi_driver(struct capi_driver *driver)
588 mutex_lock(&capi_drivers_lock);
589 list_add_tail(&driver->list, &capi_drivers);
590 mutex_unlock(&capi_drivers_lock);
593 EXPORT_SYMBOL(register_capi_driver);
596 * unregister_capi_driver() - unregister CAPI driver
597 * @driver: driver descriptor structure.
599 * Called by hardware driver to unregister itself from the CAPI subsystem.
602 void unregister_capi_driver(struct capi_driver *driver)
604 mutex_lock(&capi_drivers_lock);
605 list_del(&driver->list);
606 mutex_unlock(&capi_drivers_lock);
609 EXPORT_SYMBOL(unregister_capi_driver);
611 /* ------------------------------------------------------------- */
612 /* -------- CAPI2.0 Interface ---------------------------------- */
613 /* ------------------------------------------------------------- */
616 * capi20_isinstalled() - CAPI 2.0 operation CAPI_INSTALLED
618 * Return value: CAPI result code (CAPI_NOERROR if at least one ISDN controller
619 * is ready for use, CAPI_REGNOTINSTALLED otherwise)
622 u16 capi20_isinstalled(void)
624 u16 ret = CAPI_REGNOTINSTALLED;
627 mutex_lock(&capi_controller_lock);
629 for (i = 0; i < CAPI_MAXCONTR; i++)
630 if (capi_controller[i] &&
631 capi_controller[i]->state == CAPI_CTR_RUNNING) {
636 mutex_unlock(&capi_controller_lock);
641 EXPORT_SYMBOL(capi20_isinstalled);
644 * capi20_register() - CAPI 2.0 operation CAPI_REGISTER
645 * @ap: CAPI application descriptor structure.
647 * Register an application's presence with CAPI.
648 * A unique application ID is assigned and stored in @ap->applid.
649 * After this function returns successfully, the message receive
650 * callback function @ap->recv_message() may be called at any time
651 * until capi20_release() has been called for the same @ap.
652 * Return value: CAPI result code
655 u16 capi20_register(struct capi20_appl *ap)
663 if (ap->rparam.datablklen < 128)
664 return CAPI_LOGBLKSIZETOSMALL;
666 write_lock_irqsave(&application_lock, flags);
668 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
669 if (capi_applications[applid - 1] == NULL)
672 if (applid > CAPI_MAXAPPL) {
673 write_unlock_irqrestore(&application_lock, flags);
674 return CAPI_TOOMANYAPPLS;
678 capi_applications[applid - 1] = ap;
681 ap->nrecvdatapkt = 0;
683 ap->nsentdatapkt = 0;
684 mutex_init(&ap->recv_mtx);
685 skb_queue_head_init(&ap->recv_queue);
686 INIT_WORK(&ap->recv_work, recv_handler);
687 ap->release_in_progress = 0;
689 write_unlock_irqrestore(&application_lock, flags);
691 mutex_lock(&capi_controller_lock);
693 for (i = 0; i < CAPI_MAXCONTR; i++) {
694 if (!capi_controller[i] ||
695 capi_controller[i]->state != CAPI_CTR_RUNNING)
697 register_appl(capi_controller[i], applid, &ap->rparam);
700 mutex_unlock(&capi_controller_lock);
702 if (showcapimsgs & 1) {
703 printk(KERN_DEBUG "kcapi: appl %d up\n", applid);
709 EXPORT_SYMBOL(capi20_register);
712 * capi20_release() - CAPI 2.0 operation CAPI_RELEASE
713 * @ap: CAPI application descriptor structure.
715 * Terminate an application's registration with CAPI.
716 * After this function returns successfully, the message receive
717 * callback function @ap->recv_message() will no longer be called.
718 * Return value: CAPI result code
721 u16 capi20_release(struct capi20_appl *ap)
726 DBG("applid %#x", ap->applid);
728 write_lock_irqsave(&application_lock, flags);
729 ap->release_in_progress = 1;
730 capi_applications[ap->applid - 1] = NULL;
731 write_unlock_irqrestore(&application_lock, flags);
733 mutex_lock(&capi_controller_lock);
735 for (i = 0; i < CAPI_MAXCONTR; i++) {
736 if (!capi_controller[i] ||
737 capi_controller[i]->state != CAPI_CTR_RUNNING)
739 release_appl(capi_controller[i], ap->applid);
742 mutex_unlock(&capi_controller_lock);
744 flush_scheduled_work();
745 skb_queue_purge(&ap->recv_queue);
747 if (showcapimsgs & 1) {
748 printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid);
754 EXPORT_SYMBOL(capi20_release);
757 * capi20_put_message() - CAPI 2.0 operation CAPI_PUT_MESSAGE
758 * @ap: CAPI application descriptor structure.
759 * @skb: CAPI message.
761 * Transfer a single message to CAPI.
762 * Return value: CAPI result code
765 u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
767 struct capi_ctr *ctr;
771 DBG("applid %#x", ap->applid);
773 if (ncontrollers == 0)
774 return CAPI_REGNOTINSTALLED;
775 if ((ap->applid == 0) || ap->release_in_progress)
776 return CAPI_ILLAPPNR;
778 || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
779 || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
780 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
783 * The controller reference is protected by the existence of the
784 * application passed to us. We assume that the caller properly
785 * synchronizes this service with capi20_release.
787 ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));
788 if (!ctr || ctr->state != CAPI_CTR_RUNNING) {
789 ctr = get_capi_ctr_by_nr(1); /* XXX why? */
790 if (!ctr || ctr->state != CAPI_CTR_RUNNING)
791 return CAPI_REGNOTINSTALLED;
794 return CAPI_SENDQUEUEFULL;
796 cmd = CAPIMSG_COMMAND(skb->data);
797 subcmd = CAPIMSG_SUBCOMMAND(skb->data);
799 if (cmd == CAPI_DATA_B3 && subcmd== CAPI_REQ) {
802 if (ctr->traceflag > 2)
810 showctl |= (ctr->traceflag & 1);
813 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n",
814 CAPIMSG_CONTROLLER(skb->data),
815 CAPIMSG_APPID(skb->data),
816 capi_cmd2str(cmd, subcmd),
817 CAPIMSG_LEN(skb->data));
819 _cdebbuf *cdb = capi_message2str(skb->data);
821 printk(KERN_DEBUG "kcapi: put [%03d] %s\n",
822 CAPIMSG_CONTROLLER(skb->data),
826 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u cannot trace\n",
827 CAPIMSG_CONTROLLER(skb->data),
828 CAPIMSG_APPID(skb->data),
829 capi_cmd2str(cmd, subcmd),
830 CAPIMSG_LEN(skb->data));
833 return ctr->send_message(ctr, skb);
836 EXPORT_SYMBOL(capi20_put_message);
839 * capi20_get_manufacturer() - CAPI 2.0 operation CAPI_GET_MANUFACTURER
840 * @contr: controller number.
841 * @buf: result buffer (64 bytes).
843 * Retrieve information about the manufacturer of the specified ISDN controller
844 * or (for @contr == 0) the driver itself.
845 * Return value: CAPI result code
848 u16 capi20_get_manufacturer(u32 contr, u8 *buf)
850 struct capi_ctr *ctr;
854 strlcpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
858 mutex_lock(&capi_controller_lock);
860 ctr = get_capi_ctr_by_nr(contr);
861 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
862 strlcpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN);
865 ret = CAPI_REGNOTINSTALLED;
867 mutex_unlock(&capi_controller_lock);
871 EXPORT_SYMBOL(capi20_get_manufacturer);
874 * capi20_get_version() - CAPI 2.0 operation CAPI_GET_VERSION
875 * @contr: controller number.
876 * @verp: result structure.
878 * Retrieve version information for the specified ISDN controller
879 * or (for @contr == 0) the driver itself.
880 * Return value: CAPI result code
883 u16 capi20_get_version(u32 contr, struct capi_version *verp)
885 struct capi_ctr *ctr;
889 *verp = driver_version;
893 mutex_lock(&capi_controller_lock);
895 ctr = get_capi_ctr_by_nr(contr);
896 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
897 memcpy(verp, &ctr->version, sizeof(capi_version));
900 ret = CAPI_REGNOTINSTALLED;
902 mutex_unlock(&capi_controller_lock);
906 EXPORT_SYMBOL(capi20_get_version);
909 * capi20_get_serial() - CAPI 2.0 operation CAPI_GET_SERIAL_NUMBER
910 * @contr: controller number.
911 * @serial: result buffer (8 bytes).
913 * Retrieve the serial number of the specified ISDN controller
914 * or (for @contr == 0) the driver itself.
915 * Return value: CAPI result code
918 u16 capi20_get_serial(u32 contr, u8 *serial)
920 struct capi_ctr *ctr;
924 strlcpy(serial, driver_serial, CAPI_SERIAL_LEN);
928 mutex_lock(&capi_controller_lock);
930 ctr = get_capi_ctr_by_nr(contr);
931 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
932 strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN);
935 ret = CAPI_REGNOTINSTALLED;
937 mutex_unlock(&capi_controller_lock);
941 EXPORT_SYMBOL(capi20_get_serial);
944 * capi20_get_profile() - CAPI 2.0 operation CAPI_GET_PROFILE
945 * @contr: controller number.
946 * @profp: result structure.
948 * Retrieve capability information for the specified ISDN controller
949 * or (for @contr == 0) the number of installed controllers.
950 * Return value: CAPI result code
953 u16 capi20_get_profile(u32 contr, struct capi_profile *profp)
955 struct capi_ctr *ctr;
959 profp->ncontroller = ncontrollers;
963 mutex_lock(&capi_controller_lock);
965 ctr = get_capi_ctr_by_nr(contr);
966 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
967 memcpy(profp, &ctr->profile, sizeof(struct capi_profile));
970 ret = CAPI_REGNOTINSTALLED;
972 mutex_unlock(&capi_controller_lock);
976 EXPORT_SYMBOL(capi20_get_profile);
978 /* Must be called with capi_controller_lock held. */
979 static int wait_on_ctr_state(struct capi_ctr *ctr, unsigned int state)
984 ctr = capi_ctr_get(ctr);
989 prepare_to_wait(&ctr->state_wait_queue, &wait,
992 if (ctr->state == state)
994 if (ctr->state == CAPI_CTR_DETACHED) {
998 if (signal_pending(current)) {
1003 mutex_unlock(&capi_controller_lock);
1005 mutex_lock(&capi_controller_lock);
1007 finish_wait(&ctr->state_wait_queue, &wait);
1015 static int old_capi_manufacturer(unsigned int cmd, void __user *data)
1017 avmb1_loadandconfigdef ldef;
1018 avmb1_extcarddef cdef;
1019 avmb1_resetdef rdef;
1020 capicardparams cparams;
1021 struct capi_ctr *ctr;
1022 struct capi_driver *driver = NULL;
1024 struct list_head *l;
1029 case AVMB1_ADDCARD_WITH_TYPE:
1030 if (cmd == AVMB1_ADDCARD) {
1031 if ((retval = copy_from_user(&cdef, data,
1032 sizeof(avmb1_carddef))))
1034 cdef.cardtype = AVM_CARDTYPE_B1;
1036 if ((retval = copy_from_user(&cdef, data,
1037 sizeof(avmb1_extcarddef))))
1040 cparams.port = cdef.port;
1041 cparams.irq = cdef.irq;
1042 cparams.cardnr = cdef.cardnr;
1044 mutex_lock(&capi_drivers_lock);
1046 switch (cdef.cardtype) {
1047 case AVM_CARDTYPE_B1:
1048 list_for_each(l, &capi_drivers) {
1049 driver = list_entry(l, struct capi_driver, list);
1050 if (strcmp(driver->name, "b1isa") == 0)
1054 case AVM_CARDTYPE_T1:
1055 list_for_each(l, &capi_drivers) {
1056 driver = list_entry(l, struct capi_driver, list);
1057 if (strcmp(driver->name, "t1isa") == 0)
1066 printk(KERN_ERR "kcapi: driver not loaded.\n");
1068 } else if (!driver->add_card) {
1069 printk(KERN_ERR "kcapi: driver has no add card function.\n");
1072 retval = driver->add_card(driver, &cparams);
1074 mutex_unlock(&capi_drivers_lock);
1078 case AVMB1_LOAD_AND_CONFIG:
1080 if (cmd == AVMB1_LOAD) {
1081 if (copy_from_user(&ldef, data,
1082 sizeof(avmb1_loaddef)))
1084 ldef.t4config.len = 0;
1085 ldef.t4config.data = NULL;
1087 if (copy_from_user(&ldef, data,
1088 sizeof(avmb1_loadandconfigdef)))
1092 mutex_lock(&capi_controller_lock);
1094 ctr = get_capi_ctr_by_nr(ldef.contr);
1097 goto load_unlock_out;
1100 if (ctr->load_firmware == NULL) {
1101 printk(KERN_DEBUG "kcapi: load: no load function\n");
1103 goto load_unlock_out;
1106 if (ldef.t4file.len <= 0) {
1107 printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len);
1109 goto load_unlock_out;
1111 if (ldef.t4file.data == NULL) {
1112 printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");
1114 goto load_unlock_out;
1117 ldata.firmware.user = 1;
1118 ldata.firmware.data = ldef.t4file.data;
1119 ldata.firmware.len = ldef.t4file.len;
1120 ldata.configuration.user = 1;
1121 ldata.configuration.data = ldef.t4config.data;
1122 ldata.configuration.len = ldef.t4config.len;
1124 if (ctr->state != CAPI_CTR_DETECTED) {
1125 printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);
1127 goto load_unlock_out;
1129 ctr->state = CAPI_CTR_LOADING;
1131 retval = ctr->load_firmware(ctr, &ldata);
1133 ctr->state = CAPI_CTR_DETECTED;
1134 goto load_unlock_out;
1137 retval = wait_on_ctr_state(ctr, CAPI_CTR_RUNNING);
1140 mutex_unlock(&capi_controller_lock);
1143 case AVMB1_RESETCARD:
1144 if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef)))
1149 mutex_lock(&capi_controller_lock);
1151 ctr = get_capi_ctr_by_nr(rdef.contr);
1154 goto reset_unlock_out;
1157 if (ctr->state == CAPI_CTR_DETECTED)
1158 goto reset_unlock_out;
1160 ctr->reset_ctr(ctr);
1162 retval = wait_on_ctr_state(ctr, CAPI_CTR_DETECTED);
1165 mutex_unlock(&capi_controller_lock);
1173 * capi20_manufacturer() - CAPI 2.0 operation CAPI_MANUFACTURER
1177 * Perform manufacturer specific command.
1178 * Return value: CAPI result code
1181 int capi20_manufacturer(unsigned int cmd, void __user *data)
1183 struct capi_ctr *ctr;
1189 case AVMB1_LOAD_AND_CONFIG:
1190 case AVMB1_RESETCARD:
1191 case AVMB1_GET_CARDINFO:
1192 case AVMB1_REMOVECARD:
1193 return old_capi_manufacturer(cmd, data);
1195 case KCAPI_CMD_TRACE:
1199 if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef)))
1202 mutex_lock(&capi_controller_lock);
1204 ctr = get_capi_ctr_by_nr(fdef.contr);
1206 ctr->traceflag = fdef.flag;
1207 printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n",
1208 ctr->cnr, ctr->traceflag);
1213 mutex_unlock(&capi_controller_lock);
1217 case KCAPI_CMD_ADDCARD:
1219 struct list_head *l;
1220 struct capi_driver *driver = NULL;
1221 capicardparams cparams;
1224 if ((retval = copy_from_user(&cdef, data, sizeof(cdef))))
1227 cparams.port = cdef.port;
1228 cparams.irq = cdef.irq;
1229 cparams.membase = cdef.membase;
1230 cparams.cardnr = cdef.cardnr;
1231 cparams.cardtype = 0;
1232 cdef.driver[sizeof(cdef.driver)-1] = 0;
1234 mutex_lock(&capi_drivers_lock);
1236 list_for_each(l, &capi_drivers) {
1237 driver = list_entry(l, struct capi_driver, list);
1238 if (strcmp(driver->name, cdef.driver) == 0)
1241 if (driver == NULL) {
1242 printk(KERN_ERR "kcapi: driver \"%s\" not loaded.\n",
1245 } else if (!driver->add_card) {
1246 printk(KERN_ERR "kcapi: driver \"%s\" has no add card function.\n", cdef.driver);
1249 retval = driver->add_card(driver, &cparams);
1251 mutex_unlock(&capi_drivers_lock);
1256 printk(KERN_ERR "kcapi: manufacturer command %d unknown.\n",
1264 EXPORT_SYMBOL(capi20_manufacturer);
1266 /* ------------------------------------------------------------- */
1267 /* -------- Init & Cleanup ------------------------------------- */
1268 /* ------------------------------------------------------------- */
1271 * init / exit functions
1274 static struct notifier_block capictr_nb = {
1275 .notifier_call = notify_handler,
1276 .priority = INT_MAX,
1279 static int __init kcapi_init(void)
1283 register_capictr_notifier(&capictr_nb);
1285 err = cdebug_init();
1291 static void __exit kcapi_exit(void)
1295 /* make sure all notifiers are finished */
1296 flush_scheduled_work();
1300 module_init(kcapi_init);
1301 module_exit(kcapi_exit);