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 <linux/slab.h>
31 #include <asm/uaccess.h>
32 #include <linux/isdn/capicmd.h>
33 #include <linux/isdn/capiutil.h>
35 #include <linux/b1lli.h>
37 #include <linux/mutex.h>
38 #include <linux/rcupdate.h>
40 static int showcapimsgs = 0;
41 static struct workqueue_struct *kcapi_wq;
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 capictr_event {
51 struct work_struct work;
56 /* ------------------------------------------------------------- */
58 static struct capi_version driver_version = {2, 0, 1, 1 << 4};
59 static char driver_serial[CAPI_SERIAL_LEN] = "0004711";
60 static char capi_manufakturer[64] = "AVM Berlin";
62 #define NCCI2CTRL(ncci) (((ncci) >> 24) & 0x7f)
64 LIST_HEAD(capi_drivers);
65 DEFINE_MUTEX(capi_drivers_lock);
67 struct capi_ctr *capi_controller[CAPI_MAXCONTR];
68 DEFINE_MUTEX(capi_controller_lock);
70 struct capi20_appl *capi_applications[CAPI_MAXAPPL];
72 static int ncontrollers;
74 static BLOCKING_NOTIFIER_HEAD(ctr_notifier_list);
76 /* -------- controller ref counting -------------------------------------- */
78 static inline struct capi_ctr *
79 capi_ctr_get(struct capi_ctr *ctr)
81 if (!try_module_get(ctr->owner))
87 capi_ctr_put(struct capi_ctr *ctr)
89 module_put(ctr->owner);
92 /* ------------------------------------------------------------- */
94 static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr)
96 if (contr < 1 || contr - 1 >= CAPI_MAXCONTR)
99 return capi_controller[contr - 1];
102 static inline struct capi20_appl *__get_capi_appl_by_nr(u16 applid)
104 lockdep_assert_held(&capi_controller_lock);
106 if (applid < 1 || applid - 1 >= CAPI_MAXAPPL)
109 return capi_applications[applid - 1];
112 static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid)
114 if (applid < 1 || applid - 1 >= CAPI_MAXAPPL)
117 return rcu_dereference(capi_applications[applid - 1]);
120 /* -------- util functions ------------------------------------ */
122 static inline int capi_cmd_valid(u8 cmd)
127 case CAPI_CONNECT_ACTIVE:
128 case CAPI_CONNECT_B3_ACTIVE:
129 case CAPI_CONNECT_B3:
130 case CAPI_CONNECT_B3_T90_ACTIVE:
132 case CAPI_DISCONNECT_B3:
133 case CAPI_DISCONNECT:
137 case CAPI_MANUFACTURER:
139 case CAPI_SELECT_B_PROTOCOL:
145 static inline int capi_subcmd_valid(u8 subcmd)
157 /* ------------------------------------------------------------ */
160 register_appl(struct capi_ctr *ctr, u16 applid, capi_register_params *rparam)
162 ctr = capi_ctr_get(ctr);
165 ctr->register_appl(ctr, applid, rparam);
167 printk(KERN_WARNING "%s: cannot get controller resources\n",
172 static void release_appl(struct capi_ctr *ctr, u16 applid)
174 DBG("applid %#x", applid);
176 ctr->release_appl(ctr, applid);
180 static void notify_up(u32 contr)
182 struct capi20_appl *ap;
183 struct capi_ctr *ctr;
186 mutex_lock(&capi_controller_lock);
188 if (showcapimsgs & 1)
189 printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr);
191 ctr = get_capi_ctr_by_nr(contr);
193 if (ctr->state == CAPI_CTR_RUNNING)
196 ctr->state = CAPI_CTR_RUNNING;
198 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
199 ap = __get_capi_appl_by_nr(applid);
201 register_appl(ctr, applid, &ap->rparam);
204 wake_up_interruptible_all(&ctr->state_wait_queue);
206 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
209 mutex_unlock(&capi_controller_lock);
212 static void ctr_down(struct capi_ctr *ctr, int new_state)
214 struct capi20_appl *ap;
217 if (ctr->state == CAPI_CTR_DETECTED || ctr->state == CAPI_CTR_DETACHED)
220 ctr->state = new_state;
222 memset(ctr->manu, 0, sizeof(ctr->manu));
223 memset(&ctr->version, 0, sizeof(ctr->version));
224 memset(&ctr->profile, 0, sizeof(ctr->profile));
225 memset(ctr->serial, 0, sizeof(ctr->serial));
227 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
228 ap = __get_capi_appl_by_nr(applid);
233 wake_up_interruptible_all(&ctr->state_wait_queue);
236 static void notify_down(u32 contr)
238 struct capi_ctr *ctr;
240 mutex_lock(&capi_controller_lock);
242 if (showcapimsgs & 1)
243 printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr);
245 ctr = get_capi_ctr_by_nr(contr);
247 ctr_down(ctr, CAPI_CTR_DETECTED);
249 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
251 mutex_unlock(&capi_controller_lock);
255 notify_handler(struct notifier_block *nb, unsigned long val, void *v)
270 static void do_notify_work(struct work_struct *work)
272 struct capictr_event *event =
273 container_of(work, struct capictr_event, work);
275 blocking_notifier_call_chain(&ctr_notifier_list, event->type,
276 (void *)(long)event->controller);
281 * The notifier will result in adding/deleteing of devices. Devices can
282 * only removed in user process, not in bh.
284 static int notify_push(unsigned int event_type, u32 controller)
286 struct capictr_event *event = kmalloc(sizeof(*event), GFP_ATOMIC);
291 INIT_WORK(&event->work, do_notify_work);
292 event->type = event_type;
293 event->controller = controller;
295 queue_work(kcapi_wq, &event->work);
299 int register_capictr_notifier(struct notifier_block *nb)
301 return blocking_notifier_chain_register(&ctr_notifier_list, nb);
303 EXPORT_SYMBOL_GPL(register_capictr_notifier);
305 int unregister_capictr_notifier(struct notifier_block *nb)
307 return blocking_notifier_chain_unregister(&ctr_notifier_list, nb);
309 EXPORT_SYMBOL_GPL(unregister_capictr_notifier);
311 /* -------- Receiver ------------------------------------------ */
313 static void recv_handler(struct work_struct *work)
316 struct capi20_appl *ap =
317 container_of(work, struct capi20_appl, recv_work);
319 if ((!ap) || (ap->release_in_progress))
322 mutex_lock(&ap->recv_mtx);
323 while ((skb = skb_dequeue(&ap->recv_queue))) {
324 if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND)
329 ap->recv_message(ap, skb);
331 mutex_unlock(&ap->recv_mtx);
335 * capi_ctr_handle_message() - handle incoming CAPI message
336 * @ctr: controller descriptor structure.
337 * @appl: application ID.
340 * Called by hardware driver to pass a CAPI message to the application.
343 void capi_ctr_handle_message(struct capi_ctr *ctr, u16 appl,
346 struct capi20_appl *ap;
351 if (ctr->state != CAPI_CTR_RUNNING) {
352 cdb = capi_message2str(skb->data);
354 printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s",
358 printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n",
363 cmd = CAPIMSG_COMMAND(skb->data);
364 subcmd = CAPIMSG_SUBCOMMAND(skb->data);
365 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {
367 if (ctr->traceflag > 2)
374 showctl |= (ctr->traceflag & 1);
377 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u\n",
378 ctr->cnr, CAPIMSG_APPID(skb->data),
379 capi_cmd2str(cmd, subcmd),
380 CAPIMSG_LEN(skb->data));
382 cdb = capi_message2str(skb->data);
384 printk(KERN_DEBUG "kcapi: got [%03d] %s\n",
388 printk(KERN_DEBUG "kcapi: got [%03d] id#%d %s len=%u, cannot trace\n",
389 ctr->cnr, CAPIMSG_APPID(skb->data),
390 capi_cmd2str(cmd, subcmd),
391 CAPIMSG_LEN(skb->data));
397 ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data));
400 cdb = capi_message2str(skb->data);
402 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n",
403 CAPIMSG_APPID(skb->data), cdb->buf);
406 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s) cannot trace\n",
407 CAPIMSG_APPID(skb->data),
408 capi_cmd2str(cmd, subcmd));
411 skb_queue_tail(&ap->recv_queue, skb);
412 queue_work(kcapi_wq, &ap->recv_work);
421 EXPORT_SYMBOL(capi_ctr_handle_message);
424 * capi_ctr_ready() - signal CAPI controller ready
425 * @ctr: controller descriptor structure.
427 * Called by hardware driver to signal that the controller is up and running.
430 void capi_ctr_ready(struct capi_ctr *ctr)
432 printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n",
433 ctr->cnr, ctr->name);
435 notify_push(CAPICTR_UP, ctr->cnr);
438 EXPORT_SYMBOL(capi_ctr_ready);
441 * capi_ctr_down() - signal CAPI controller not ready
442 * @ctr: controller descriptor structure.
444 * Called by hardware driver to signal that the controller is down and
445 * unavailable for use.
448 void capi_ctr_down(struct capi_ctr *ctr)
450 printk(KERN_NOTICE "kcapi: controller [%03d] down.\n", ctr->cnr);
452 notify_push(CAPICTR_DOWN, ctr->cnr);
455 EXPORT_SYMBOL(capi_ctr_down);
458 * capi_ctr_suspend_output() - suspend controller
459 * @ctr: controller descriptor structure.
461 * Called by hardware driver to stop data flow.
463 * Note: The caller is responsible for synchronizing concurrent state changes
464 * as well as invocations of capi_ctr_handle_message.
467 void capi_ctr_suspend_output(struct capi_ctr *ctr)
470 printk(KERN_DEBUG "kcapi: controller [%03d] suspend\n",
476 EXPORT_SYMBOL(capi_ctr_suspend_output);
479 * capi_ctr_resume_output() - resume controller
480 * @ctr: controller descriptor structure.
482 * Called by hardware driver to resume data flow.
484 * Note: The caller is responsible for synchronizing concurrent state changes
485 * as well as invocations of capi_ctr_handle_message.
488 void capi_ctr_resume_output(struct capi_ctr *ctr)
491 printk(KERN_DEBUG "kcapi: controller [%03d] resumed\n",
497 EXPORT_SYMBOL(capi_ctr_resume_output);
499 /* ------------------------------------------------------------- */
502 * attach_capi_ctr() - register CAPI controller
503 * @ctr: controller descriptor structure.
505 * Called by hardware driver to register a controller with the CAPI subsystem.
506 * Return value: 0 on success, error code < 0 on error
509 int attach_capi_ctr(struct capi_ctr *ctr)
513 mutex_lock(&capi_controller_lock);
515 for (i = 0; i < CAPI_MAXCONTR; i++) {
516 if (!capi_controller[i])
519 if (i == CAPI_MAXCONTR) {
520 mutex_unlock(&capi_controller_lock);
521 printk(KERN_ERR "kcapi: out of controller slots\n");
524 capi_controller[i] = ctr;
526 ctr->nrecvctlpkt = 0;
527 ctr->nrecvdatapkt = 0;
528 ctr->nsentctlpkt = 0;
529 ctr->nsentdatapkt = 0;
531 ctr->state = CAPI_CTR_DETECTED;
533 ctr->traceflag = showcapimsgs;
534 init_waitqueue_head(&ctr->state_wait_queue);
536 sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr);
537 ctr->procent = proc_create_data(ctr->procfn, 0, NULL, ctr->proc_fops, ctr);
541 mutex_unlock(&capi_controller_lock);
543 printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n",
544 ctr->cnr, ctr->name);
548 EXPORT_SYMBOL(attach_capi_ctr);
551 * detach_capi_ctr() - unregister CAPI controller
552 * @ctr: controller descriptor structure.
554 * Called by hardware driver to remove the registration of a controller
555 * with the CAPI subsystem.
556 * Return value: 0 on success, error code < 0 on error
559 int detach_capi_ctr(struct capi_ctr *ctr)
563 mutex_lock(&capi_controller_lock);
565 ctr_down(ctr, CAPI_CTR_DETACHED);
567 if (ctr->cnr < 1 || ctr->cnr - 1 >= CAPI_MAXCONTR) {
572 if (capi_controller[ctr->cnr - 1] != ctr) {
576 capi_controller[ctr->cnr - 1] = NULL;
580 remove_proc_entry(ctr->procfn, NULL);
582 printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n",
583 ctr->cnr, ctr->name);
586 mutex_unlock(&capi_controller_lock);
591 EXPORT_SYMBOL(detach_capi_ctr);
594 * register_capi_driver() - register CAPI driver
595 * @driver: driver descriptor structure.
597 * Called by hardware driver to register itself with the CAPI subsystem.
600 void register_capi_driver(struct capi_driver *driver)
602 mutex_lock(&capi_drivers_lock);
603 list_add_tail(&driver->list, &capi_drivers);
604 mutex_unlock(&capi_drivers_lock);
607 EXPORT_SYMBOL(register_capi_driver);
610 * unregister_capi_driver() - unregister CAPI driver
611 * @driver: driver descriptor structure.
613 * Called by hardware driver to unregister itself from the CAPI subsystem.
616 void unregister_capi_driver(struct capi_driver *driver)
618 mutex_lock(&capi_drivers_lock);
619 list_del(&driver->list);
620 mutex_unlock(&capi_drivers_lock);
623 EXPORT_SYMBOL(unregister_capi_driver);
625 /* ------------------------------------------------------------- */
626 /* -------- CAPI2.0 Interface ---------------------------------- */
627 /* ------------------------------------------------------------- */
630 * capi20_isinstalled() - CAPI 2.0 operation CAPI_INSTALLED
632 * Return value: CAPI result code (CAPI_NOERROR if at least one ISDN controller
633 * is ready for use, CAPI_REGNOTINSTALLED otherwise)
636 u16 capi20_isinstalled(void)
638 u16 ret = CAPI_REGNOTINSTALLED;
641 mutex_lock(&capi_controller_lock);
643 for (i = 0; i < CAPI_MAXCONTR; i++)
644 if (capi_controller[i] &&
645 capi_controller[i]->state == CAPI_CTR_RUNNING) {
650 mutex_unlock(&capi_controller_lock);
655 EXPORT_SYMBOL(capi20_isinstalled);
658 * capi20_register() - CAPI 2.0 operation CAPI_REGISTER
659 * @ap: CAPI application descriptor structure.
661 * Register an application's presence with CAPI.
662 * A unique application ID is assigned and stored in @ap->applid.
663 * After this function returns successfully, the message receive
664 * callback function @ap->recv_message() may be called at any time
665 * until capi20_release() has been called for the same @ap.
666 * Return value: CAPI result code
669 u16 capi20_register(struct capi20_appl *ap)
676 if (ap->rparam.datablklen < 128)
677 return CAPI_LOGBLKSIZETOSMALL;
680 ap->nrecvdatapkt = 0;
682 ap->nsentdatapkt = 0;
683 mutex_init(&ap->recv_mtx);
684 skb_queue_head_init(&ap->recv_queue);
685 INIT_WORK(&ap->recv_work, recv_handler);
686 ap->release_in_progress = 0;
688 mutex_lock(&capi_controller_lock);
690 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
691 if (capi_applications[applid - 1] == NULL)
694 if (applid > CAPI_MAXAPPL) {
695 mutex_unlock(&capi_controller_lock);
696 return CAPI_TOOMANYAPPLS;
700 capi_applications[applid - 1] = ap;
702 for (i = 0; i < CAPI_MAXCONTR; i++) {
703 if (!capi_controller[i] ||
704 capi_controller[i]->state != CAPI_CTR_RUNNING)
706 register_appl(capi_controller[i], applid, &ap->rparam);
709 mutex_unlock(&capi_controller_lock);
711 if (showcapimsgs & 1) {
712 printk(KERN_DEBUG "kcapi: appl %d up\n", applid);
718 EXPORT_SYMBOL(capi20_register);
721 * capi20_release() - CAPI 2.0 operation CAPI_RELEASE
722 * @ap: CAPI application descriptor structure.
724 * Terminate an application's registration with CAPI.
725 * After this function returns successfully, the message receive
726 * callback function @ap->recv_message() will no longer be called.
727 * Return value: CAPI result code
730 u16 capi20_release(struct capi20_appl *ap)
734 DBG("applid %#x", ap->applid);
736 mutex_lock(&capi_controller_lock);
738 ap->release_in_progress = 1;
739 capi_applications[ap->applid - 1] = NULL;
743 for (i = 0; i < CAPI_MAXCONTR; i++) {
744 if (!capi_controller[i] ||
745 capi_controller[i]->state != CAPI_CTR_RUNNING)
747 release_appl(capi_controller[i], ap->applid);
750 mutex_unlock(&capi_controller_lock);
752 flush_workqueue(kcapi_wq);
753 skb_queue_purge(&ap->recv_queue);
755 if (showcapimsgs & 1) {
756 printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid);
762 EXPORT_SYMBOL(capi20_release);
765 * capi20_put_message() - CAPI 2.0 operation CAPI_PUT_MESSAGE
766 * @ap: CAPI application descriptor structure.
767 * @skb: CAPI message.
769 * Transfer a single message to CAPI.
770 * Return value: CAPI result code
773 u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
775 struct capi_ctr *ctr;
779 DBG("applid %#x", ap->applid);
781 if (ncontrollers == 0)
782 return CAPI_REGNOTINSTALLED;
783 if ((ap->applid == 0) || ap->release_in_progress)
784 return CAPI_ILLAPPNR;
786 || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
787 || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
788 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
791 * The controller reference is protected by the existence of the
792 * application passed to us. We assume that the caller properly
793 * synchronizes this service with capi20_release.
795 ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));
796 if (!ctr || ctr->state != CAPI_CTR_RUNNING)
797 return CAPI_REGNOTINSTALLED;
799 return CAPI_SENDQUEUEFULL;
801 cmd = CAPIMSG_COMMAND(skb->data);
802 subcmd = CAPIMSG_SUBCOMMAND(skb->data);
804 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_REQ) {
807 if (ctr->traceflag > 2)
815 showctl |= (ctr->traceflag & 1);
818 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n",
819 CAPIMSG_CONTROLLER(skb->data),
820 CAPIMSG_APPID(skb->data),
821 capi_cmd2str(cmd, subcmd),
822 CAPIMSG_LEN(skb->data));
824 _cdebbuf *cdb = capi_message2str(skb->data);
826 printk(KERN_DEBUG "kcapi: put [%03d] %s\n",
827 CAPIMSG_CONTROLLER(skb->data),
831 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u cannot trace\n",
832 CAPIMSG_CONTROLLER(skb->data),
833 CAPIMSG_APPID(skb->data),
834 capi_cmd2str(cmd, subcmd),
835 CAPIMSG_LEN(skb->data));
838 return ctr->send_message(ctr, skb);
841 EXPORT_SYMBOL(capi20_put_message);
844 * capi20_get_manufacturer() - CAPI 2.0 operation CAPI_GET_MANUFACTURER
845 * @contr: controller number.
846 * @buf: result buffer (64 bytes).
848 * Retrieve information about the manufacturer of the specified ISDN controller
849 * or (for @contr == 0) the driver itself.
850 * Return value: CAPI result code
853 u16 capi20_get_manufacturer(u32 contr, u8 buf[CAPI_MANUFACTURER_LEN])
855 struct capi_ctr *ctr;
859 strncpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
863 mutex_lock(&capi_controller_lock);
865 ctr = get_capi_ctr_by_nr(contr);
866 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
867 strncpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN);
870 ret = CAPI_REGNOTINSTALLED;
872 mutex_unlock(&capi_controller_lock);
876 EXPORT_SYMBOL(capi20_get_manufacturer);
879 * capi20_get_version() - CAPI 2.0 operation CAPI_GET_VERSION
880 * @contr: controller number.
881 * @verp: result structure.
883 * Retrieve version information for the specified ISDN controller
884 * or (for @contr == 0) the driver itself.
885 * Return value: CAPI result code
888 u16 capi20_get_version(u32 contr, struct capi_version *verp)
890 struct capi_ctr *ctr;
894 *verp = driver_version;
898 mutex_lock(&capi_controller_lock);
900 ctr = get_capi_ctr_by_nr(contr);
901 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
902 memcpy(verp, &ctr->version, sizeof(capi_version));
905 ret = CAPI_REGNOTINSTALLED;
907 mutex_unlock(&capi_controller_lock);
911 EXPORT_SYMBOL(capi20_get_version);
914 * capi20_get_serial() - CAPI 2.0 operation CAPI_GET_SERIAL_NUMBER
915 * @contr: controller number.
916 * @serial: result buffer (8 bytes).
918 * Retrieve the serial number of the specified ISDN controller
919 * or (for @contr == 0) the driver itself.
920 * Return value: CAPI result code
923 u16 capi20_get_serial(u32 contr, u8 serial[CAPI_SERIAL_LEN])
925 struct capi_ctr *ctr;
929 strlcpy(serial, driver_serial, CAPI_SERIAL_LEN);
933 mutex_lock(&capi_controller_lock);
935 ctr = get_capi_ctr_by_nr(contr);
936 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
937 strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN);
940 ret = CAPI_REGNOTINSTALLED;
942 mutex_unlock(&capi_controller_lock);
946 EXPORT_SYMBOL(capi20_get_serial);
949 * capi20_get_profile() - CAPI 2.0 operation CAPI_GET_PROFILE
950 * @contr: controller number.
951 * @profp: result structure.
953 * Retrieve capability information for the specified ISDN controller
954 * or (for @contr == 0) the number of installed controllers.
955 * Return value: CAPI result code
958 u16 capi20_get_profile(u32 contr, struct capi_profile *profp)
960 struct capi_ctr *ctr;
964 profp->ncontroller = ncontrollers;
968 mutex_lock(&capi_controller_lock);
970 ctr = get_capi_ctr_by_nr(contr);
971 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
972 memcpy(profp, &ctr->profile, sizeof(struct capi_profile));
975 ret = CAPI_REGNOTINSTALLED;
977 mutex_unlock(&capi_controller_lock);
981 EXPORT_SYMBOL(capi20_get_profile);
983 /* Must be called with capi_controller_lock held. */
984 static int wait_on_ctr_state(struct capi_ctr *ctr, unsigned int state)
989 ctr = capi_ctr_get(ctr);
994 prepare_to_wait(&ctr->state_wait_queue, &wait,
997 if (ctr->state == state)
999 if (ctr->state == CAPI_CTR_DETACHED) {
1003 if (signal_pending(current)) {
1008 mutex_unlock(&capi_controller_lock);
1010 mutex_lock(&capi_controller_lock);
1012 finish_wait(&ctr->state_wait_queue, &wait);
1020 static int old_capi_manufacturer(unsigned int cmd, void __user *data)
1022 avmb1_loadandconfigdef ldef;
1023 avmb1_extcarddef cdef;
1024 avmb1_resetdef rdef;
1025 capicardparams cparams;
1026 struct capi_ctr *ctr;
1027 struct capi_driver *driver = NULL;
1029 struct list_head *l;
1034 case AVMB1_ADDCARD_WITH_TYPE:
1035 if (cmd == AVMB1_ADDCARD) {
1036 if ((retval = copy_from_user(&cdef, data,
1037 sizeof(avmb1_carddef))))
1039 cdef.cardtype = AVM_CARDTYPE_B1;
1042 if ((retval = copy_from_user(&cdef, data,
1043 sizeof(avmb1_extcarddef))))
1046 cparams.port = cdef.port;
1047 cparams.irq = cdef.irq;
1048 cparams.cardnr = cdef.cardnr;
1050 mutex_lock(&capi_drivers_lock);
1052 switch (cdef.cardtype) {
1053 case AVM_CARDTYPE_B1:
1054 list_for_each(l, &capi_drivers) {
1055 driver = list_entry(l, struct capi_driver, list);
1056 if (strcmp(driver->name, "b1isa") == 0)
1060 case AVM_CARDTYPE_T1:
1061 list_for_each(l, &capi_drivers) {
1062 driver = list_entry(l, struct capi_driver, list);
1063 if (strcmp(driver->name, "t1isa") == 0)
1072 printk(KERN_ERR "kcapi: driver not loaded.\n");
1074 } else if (!driver->add_card) {
1075 printk(KERN_ERR "kcapi: driver has no add card function.\n");
1078 retval = driver->add_card(driver, &cparams);
1080 mutex_unlock(&capi_drivers_lock);
1084 case AVMB1_LOAD_AND_CONFIG:
1086 if (cmd == AVMB1_LOAD) {
1087 if (copy_from_user(&ldef, data,
1088 sizeof(avmb1_loaddef)))
1090 ldef.t4config.len = 0;
1091 ldef.t4config.data = NULL;
1093 if (copy_from_user(&ldef, data,
1094 sizeof(avmb1_loadandconfigdef)))
1098 mutex_lock(&capi_controller_lock);
1100 ctr = get_capi_ctr_by_nr(ldef.contr);
1103 goto load_unlock_out;
1106 if (ctr->load_firmware == NULL) {
1107 printk(KERN_DEBUG "kcapi: load: no load function\n");
1109 goto load_unlock_out;
1112 if (ldef.t4file.len <= 0) {
1113 printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len);
1115 goto load_unlock_out;
1117 if (ldef.t4file.data == NULL) {
1118 printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");
1120 goto load_unlock_out;
1123 ldata.firmware.user = 1;
1124 ldata.firmware.data = ldef.t4file.data;
1125 ldata.firmware.len = ldef.t4file.len;
1126 ldata.configuration.user = 1;
1127 ldata.configuration.data = ldef.t4config.data;
1128 ldata.configuration.len = ldef.t4config.len;
1130 if (ctr->state != CAPI_CTR_DETECTED) {
1131 printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);
1133 goto load_unlock_out;
1135 ctr->state = CAPI_CTR_LOADING;
1137 retval = ctr->load_firmware(ctr, &ldata);
1139 ctr->state = CAPI_CTR_DETECTED;
1140 goto load_unlock_out;
1143 retval = wait_on_ctr_state(ctr, CAPI_CTR_RUNNING);
1146 mutex_unlock(&capi_controller_lock);
1149 case AVMB1_RESETCARD:
1150 if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef)))
1155 mutex_lock(&capi_controller_lock);
1157 ctr = get_capi_ctr_by_nr(rdef.contr);
1160 goto reset_unlock_out;
1163 if (ctr->state == CAPI_CTR_DETECTED)
1164 goto reset_unlock_out;
1166 if (ctr->reset_ctr == NULL) {
1167 printk(KERN_DEBUG "kcapi: reset: no reset function\n");
1169 goto reset_unlock_out;
1172 ctr->reset_ctr(ctr);
1174 retval = wait_on_ctr_state(ctr, CAPI_CTR_DETECTED);
1177 mutex_unlock(&capi_controller_lock);
1185 * capi20_manufacturer() - CAPI 2.0 operation CAPI_MANUFACTURER
1189 * Perform manufacturer specific command.
1190 * Return value: CAPI result code
1193 int capi20_manufacturer(unsigned long cmd, void __user *data)
1195 struct capi_ctr *ctr;
1201 case AVMB1_LOAD_AND_CONFIG:
1202 case AVMB1_RESETCARD:
1203 case AVMB1_GET_CARDINFO:
1204 case AVMB1_REMOVECARD:
1205 return old_capi_manufacturer(cmd, data);
1207 case KCAPI_CMD_TRACE:
1211 if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef)))
1214 mutex_lock(&capi_controller_lock);
1216 ctr = get_capi_ctr_by_nr(fdef.contr);
1218 ctr->traceflag = fdef.flag;
1219 printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n",
1220 ctr->cnr, ctr->traceflag);
1225 mutex_unlock(&capi_controller_lock);
1229 case KCAPI_CMD_ADDCARD:
1231 struct list_head *l;
1232 struct capi_driver *driver = NULL;
1233 capicardparams cparams;
1236 if ((retval = copy_from_user(&cdef, data, sizeof(cdef))))
1239 cparams.port = cdef.port;
1240 cparams.irq = cdef.irq;
1241 cparams.membase = cdef.membase;
1242 cparams.cardnr = cdef.cardnr;
1243 cparams.cardtype = 0;
1244 cdef.driver[sizeof(cdef.driver) - 1] = 0;
1246 mutex_lock(&capi_drivers_lock);
1248 list_for_each(l, &capi_drivers) {
1249 driver = list_entry(l, struct capi_driver, list);
1250 if (strcmp(driver->name, cdef.driver) == 0)
1253 if (driver == NULL) {
1254 printk(KERN_ERR "kcapi: driver \"%s\" not loaded.\n",
1257 } else if (!driver->add_card) {
1258 printk(KERN_ERR "kcapi: driver \"%s\" has no add card function.\n", cdef.driver);
1261 retval = driver->add_card(driver, &cparams);
1263 mutex_unlock(&capi_drivers_lock);
1268 printk(KERN_ERR "kcapi: manufacturer command %lu unknown.\n",
1276 EXPORT_SYMBOL(capi20_manufacturer);
1278 /* ------------------------------------------------------------- */
1279 /* -------- Init & Cleanup ------------------------------------- */
1280 /* ------------------------------------------------------------- */
1283 * init / exit functions
1286 static struct notifier_block capictr_nb = {
1287 .notifier_call = notify_handler,
1288 .priority = INT_MAX,
1291 static int __init kcapi_init(void)
1295 kcapi_wq = alloc_workqueue("kcapi", 0, 0);
1299 register_capictr_notifier(&capictr_nb);
1301 err = cdebug_init();
1303 unregister_capictr_notifier(&capictr_nb);
1304 destroy_workqueue(kcapi_wq);
1312 static void __exit kcapi_exit(void)
1316 unregister_capictr_notifier(&capictr_nb);
1318 destroy_workqueue(kcapi_wq);
1321 module_init(kcapi_init);
1322 module_exit(kcapi_exit);