1
2
3
4
5
6
7
8
9
10
11
12
13#define AVMB1_COMPAT
14
15#include "kcapi.h"
16#include <linux/module.h>
17#include <linux/mm.h>
18#include <linux/interrupt.h>
19#include <linux/ioport.h>
20#include <linux/proc_fs.h>
21#include <linux/sched/signal.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 <linux/uaccess.h>
32#include <linux/isdn/capicmd.h>
33#include <linux/isdn/capiutil.h>
34#ifdef AVMB1_COMPAT
35#include <linux/b1lli.h>
36#endif
37#include <linux/mutex.h>
38#include <linux/rcupdate.h>
39
40static int showcapimsgs = 0;
41static struct workqueue_struct *kcapi_wq;
42
43MODULE_DESCRIPTION("CAPI4Linux: kernel CAPI layer");
44MODULE_AUTHOR("Carsten Paeth");
45MODULE_LICENSE("GPL");
46module_param(showcapimsgs, uint, 0);
47
48
49
50struct capictr_event {
51 struct work_struct work;
52 unsigned int type;
53 u32 controller;
54};
55
56
57
58static const struct capi_version driver_version = {2, 0, 1, 1 << 4};
59static char driver_serial[CAPI_SERIAL_LEN] = "0004711";
60static char capi_manufakturer[64] = "AVM Berlin";
61
62#define NCCI2CTRL(ncci) (((ncci) >> 24) & 0x7f)
63
64LIST_HEAD(capi_drivers);
65DEFINE_MUTEX(capi_drivers_lock);
66
67struct capi_ctr *capi_controller[CAPI_MAXCONTR];
68DEFINE_MUTEX(capi_controller_lock);
69
70struct capi20_appl *capi_applications[CAPI_MAXAPPL];
71
72static int ncontrollers;
73
74static BLOCKING_NOTIFIER_HEAD(ctr_notifier_list);
75
76
77
78static inline struct capi_ctr *
79capi_ctr_get(struct capi_ctr *ctr)
80{
81 if (!try_module_get(ctr->owner))
82 return NULL;
83 return ctr;
84}
85
86static inline void
87capi_ctr_put(struct capi_ctr *ctr)
88{
89 module_put(ctr->owner);
90}
91
92
93
94static inline struct capi_ctr *get_capi_ctr_by_nr(u16 contr)
95{
96 if (contr < 1 || contr - 1 >= CAPI_MAXCONTR)
97 return NULL;
98
99 return capi_controller[contr - 1];
100}
101
102static inline struct capi20_appl *__get_capi_appl_by_nr(u16 applid)
103{
104 lockdep_assert_held(&capi_controller_lock);
105
106 if (applid < 1 || applid - 1 >= CAPI_MAXAPPL)
107 return NULL;
108
109 return capi_applications[applid - 1];
110}
111
112static inline struct capi20_appl *get_capi_appl_by_nr(u16 applid)
113{
114 if (applid < 1 || applid - 1 >= CAPI_MAXAPPL)
115 return NULL;
116
117 return rcu_dereference(capi_applications[applid - 1]);
118}
119
120
121
122static inline int capi_cmd_valid(u8 cmd)
123{
124 switch (cmd) {
125 case CAPI_ALERT:
126 case CAPI_CONNECT:
127 case CAPI_CONNECT_ACTIVE:
128 case CAPI_CONNECT_B3_ACTIVE:
129 case CAPI_CONNECT_B3:
130 case CAPI_CONNECT_B3_T90_ACTIVE:
131 case CAPI_DATA_B3:
132 case CAPI_DISCONNECT_B3:
133 case CAPI_DISCONNECT:
134 case CAPI_FACILITY:
135 case CAPI_INFO:
136 case CAPI_LISTEN:
137 case CAPI_MANUFACTURER:
138 case CAPI_RESET_B3:
139 case CAPI_SELECT_B_PROTOCOL:
140 return 1;
141 }
142 return 0;
143}
144
145static inline int capi_subcmd_valid(u8 subcmd)
146{
147 switch (subcmd) {
148 case CAPI_REQ:
149 case CAPI_CONF:
150 case CAPI_IND:
151 case CAPI_RESP:
152 return 1;
153 }
154 return 0;
155}
156
157
158
159static void
160register_appl(struct capi_ctr *ctr, u16 applid, capi_register_params *rparam)
161{
162 ctr = capi_ctr_get(ctr);
163
164 if (ctr)
165 ctr->register_appl(ctr, applid, rparam);
166 else
167 printk(KERN_WARNING "%s: cannot get controller resources\n",
168 __func__);
169}
170
171
172static void release_appl(struct capi_ctr *ctr, u16 applid)
173{
174 DBG("applid %#x", applid);
175
176 ctr->release_appl(ctr, applid);
177 capi_ctr_put(ctr);
178}
179
180static void notify_up(u32 contr)
181{
182 struct capi20_appl *ap;
183 struct capi_ctr *ctr;
184 u16 applid;
185
186 mutex_lock(&capi_controller_lock);
187
188 if (showcapimsgs & 1)
189 printk(KERN_DEBUG "kcapi: notify up contr %d\n", contr);
190
191 ctr = get_capi_ctr_by_nr(contr);
192 if (ctr) {
193 if (ctr->state == CAPI_CTR_RUNNING)
194 goto unlock_out;
195
196 ctr->state = CAPI_CTR_RUNNING;
197
198 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
199 ap = __get_capi_appl_by_nr(applid);
200 if (ap)
201 register_appl(ctr, applid, &ap->rparam);
202 }
203
204 wake_up_interruptible_all(&ctr->state_wait_queue);
205 } else
206 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
207
208unlock_out:
209 mutex_unlock(&capi_controller_lock);
210}
211
212static void ctr_down(struct capi_ctr *ctr, int new_state)
213{
214 struct capi20_appl *ap;
215 u16 applid;
216
217 if (ctr->state == CAPI_CTR_DETECTED || ctr->state == CAPI_CTR_DETACHED)
218 return;
219
220 ctr->state = new_state;
221
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));
226
227 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
228 ap = __get_capi_appl_by_nr(applid);
229 if (ap)
230 capi_ctr_put(ctr);
231 }
232
233 wake_up_interruptible_all(&ctr->state_wait_queue);
234}
235
236static void notify_down(u32 contr)
237{
238 struct capi_ctr *ctr;
239
240 mutex_lock(&capi_controller_lock);
241
242 if (showcapimsgs & 1)
243 printk(KERN_DEBUG "kcapi: notify down contr %d\n", contr);
244
245 ctr = get_capi_ctr_by_nr(contr);
246 if (ctr)
247 ctr_down(ctr, CAPI_CTR_DETECTED);
248 else
249 printk(KERN_WARNING "%s: invalid contr %d\n", __func__, contr);
250
251 mutex_unlock(&capi_controller_lock);
252}
253
254static int
255notify_handler(struct notifier_block *nb, unsigned long val, void *v)
256{
257 u32 contr = (long)v;
258
259 switch (val) {
260 case CAPICTR_UP:
261 notify_up(contr);
262 break;
263 case CAPICTR_DOWN:
264 notify_down(contr);
265 break;
266 }
267 return NOTIFY_OK;
268}
269
270static void do_notify_work(struct work_struct *work)
271{
272 struct capictr_event *event =
273 container_of(work, struct capictr_event, work);
274
275 blocking_notifier_call_chain(&ctr_notifier_list, event->type,
276 (void *)(long)event->controller);
277 kfree(event);
278}
279
280
281
282
283
284static int notify_push(unsigned int event_type, u32 controller)
285{
286 struct capictr_event *event = kmalloc(sizeof(*event), GFP_ATOMIC);
287
288 if (!event)
289 return -ENOMEM;
290
291 INIT_WORK(&event->work, do_notify_work);
292 event->type = event_type;
293 event->controller = controller;
294
295 queue_work(kcapi_wq, &event->work);
296 return 0;
297}
298
299int register_capictr_notifier(struct notifier_block *nb)
300{
301 return blocking_notifier_chain_register(&ctr_notifier_list, nb);
302}
303EXPORT_SYMBOL_GPL(register_capictr_notifier);
304
305int unregister_capictr_notifier(struct notifier_block *nb)
306{
307 return blocking_notifier_chain_unregister(&ctr_notifier_list, nb);
308}
309EXPORT_SYMBOL_GPL(unregister_capictr_notifier);
310
311
312
313static void recv_handler(struct work_struct *work)
314{
315 struct sk_buff *skb;
316 struct capi20_appl *ap =
317 container_of(work, struct capi20_appl, recv_work);
318
319 if ((!ap) || (ap->release_in_progress))
320 return;
321
322 mutex_lock(&ap->recv_mtx);
323 while ((skb = skb_dequeue(&ap->recv_queue))) {
324 if (CAPIMSG_CMD(skb->data) == CAPI_DATA_B3_IND)
325 ap->nrecvdatapkt++;
326 else
327 ap->nrecvctlpkt++;
328
329 ap->recv_message(ap, skb);
330 }
331 mutex_unlock(&ap->recv_mtx);
332}
333
334
335
336
337
338
339
340
341
342
343void capi_ctr_handle_message(struct capi_ctr *ctr, u16 appl,
344 struct sk_buff *skb)
345{
346 struct capi20_appl *ap;
347 int showctl = 0;
348 u8 cmd, subcmd;
349 _cdebbuf *cdb;
350
351 if (ctr->state != CAPI_CTR_RUNNING) {
352 cdb = capi_message2str(skb->data);
353 if (cdb) {
354 printk(KERN_INFO "kcapi: controller [%03d] not active, got: %s",
355 ctr->cnr, cdb->buf);
356 cdebbuf_free(cdb);
357 } else
358 printk(KERN_INFO "kcapi: controller [%03d] not active, cannot trace\n",
359 ctr->cnr);
360 goto error;
361 }
362
363 cmd = CAPIMSG_COMMAND(skb->data);
364 subcmd = CAPIMSG_SUBCOMMAND(skb->data);
365 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_IND) {
366 ctr->nrecvdatapkt++;
367 if (ctr->traceflag > 2)
368 showctl |= 2;
369 } else {
370 ctr->nrecvctlpkt++;
371 if (ctr->traceflag)
372 showctl |= 2;
373 }
374 showctl |= (ctr->traceflag & 1);
375 if (showctl & 2) {
376 if (showctl & 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));
381 } else {
382 cdb = capi_message2str(skb->data);
383 if (cdb) {
384 printk(KERN_DEBUG "kcapi: got [%03d] %s\n",
385 ctr->cnr, cdb->buf);
386 cdebbuf_free(cdb);
387 } else
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));
392 }
393
394 }
395
396 rcu_read_lock();
397 ap = get_capi_appl_by_nr(CAPIMSG_APPID(skb->data));
398 if (!ap) {
399 rcu_read_unlock();
400 cdb = capi_message2str(skb->data);
401 if (cdb) {
402 printk(KERN_ERR "kcapi: handle_message: applid %d state released (%s)\n",
403 CAPIMSG_APPID(skb->data), cdb->buf);
404 cdebbuf_free(cdb);
405 } else
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));
409 goto error;
410 }
411 skb_queue_tail(&ap->recv_queue, skb);
412 queue_work(kcapi_wq, &ap->recv_work);
413 rcu_read_unlock();
414
415 return;
416
417error:
418 kfree_skb(skb);
419}
420
421EXPORT_SYMBOL(capi_ctr_handle_message);
422
423
424
425
426
427
428
429
430void capi_ctr_ready(struct capi_ctr *ctr)
431{
432 printk(KERN_NOTICE "kcapi: controller [%03d] \"%s\" ready.\n",
433 ctr->cnr, ctr->name);
434
435 notify_push(CAPICTR_UP, ctr->cnr);
436}
437
438EXPORT_SYMBOL(capi_ctr_ready);
439
440
441
442
443
444
445
446
447
448void capi_ctr_down(struct capi_ctr *ctr)
449{
450 printk(KERN_NOTICE "kcapi: controller [%03d] down.\n", ctr->cnr);
451
452 notify_push(CAPICTR_DOWN, ctr->cnr);
453}
454
455EXPORT_SYMBOL(capi_ctr_down);
456
457
458
459
460
461
462
463
464
465
466
467void capi_ctr_suspend_output(struct capi_ctr *ctr)
468{
469 if (!ctr->blocked) {
470 printk(KERN_DEBUG "kcapi: controller [%03d] suspend\n",
471 ctr->cnr);
472 ctr->blocked = 1;
473 }
474}
475
476EXPORT_SYMBOL(capi_ctr_suspend_output);
477
478
479
480
481
482
483
484
485
486
487
488void capi_ctr_resume_output(struct capi_ctr *ctr)
489{
490 if (ctr->blocked) {
491 printk(KERN_DEBUG "kcapi: controller [%03d] resumed\n",
492 ctr->cnr);
493 ctr->blocked = 0;
494 }
495}
496
497EXPORT_SYMBOL(capi_ctr_resume_output);
498
499
500
501
502
503
504
505
506
507
508
509int attach_capi_ctr(struct capi_ctr *ctr)
510{
511 int i;
512
513 mutex_lock(&capi_controller_lock);
514
515 for (i = 0; i < CAPI_MAXCONTR; i++) {
516 if (!capi_controller[i])
517 break;
518 }
519 if (i == CAPI_MAXCONTR) {
520 mutex_unlock(&capi_controller_lock);
521 printk(KERN_ERR "kcapi: out of controller slots\n");
522 return -EBUSY;
523 }
524 capi_controller[i] = ctr;
525
526 ctr->nrecvctlpkt = 0;
527 ctr->nrecvdatapkt = 0;
528 ctr->nsentctlpkt = 0;
529 ctr->nsentdatapkt = 0;
530 ctr->cnr = i + 1;
531 ctr->state = CAPI_CTR_DETECTED;
532 ctr->blocked = 0;
533 ctr->traceflag = showcapimsgs;
534 init_waitqueue_head(&ctr->state_wait_queue);
535
536 sprintf(ctr->procfn, "capi/controllers/%d", ctr->cnr);
537 ctr->procent = proc_create_single_data(ctr->procfn, 0, NULL,
538 ctr->proc_show, ctr);
539
540 ncontrollers++;
541
542 mutex_unlock(&capi_controller_lock);
543
544 printk(KERN_NOTICE "kcapi: controller [%03d]: %s attached\n",
545 ctr->cnr, ctr->name);
546 return 0;
547}
548
549EXPORT_SYMBOL(attach_capi_ctr);
550
551
552
553
554
555
556
557
558
559
560int detach_capi_ctr(struct capi_ctr *ctr)
561{
562 int err = 0;
563
564 mutex_lock(&capi_controller_lock);
565
566 ctr_down(ctr, CAPI_CTR_DETACHED);
567
568 if (capi_controller[ctr->cnr - 1] != ctr) {
569 err = -EINVAL;
570 goto unlock_out;
571 }
572 capi_controller[ctr->cnr - 1] = NULL;
573 ncontrollers--;
574
575 if (ctr->procent)
576 remove_proc_entry(ctr->procfn, NULL);
577
578 printk(KERN_NOTICE "kcapi: controller [%03d]: %s unregistered\n",
579 ctr->cnr, ctr->name);
580
581unlock_out:
582 mutex_unlock(&capi_controller_lock);
583
584 return err;
585}
586
587EXPORT_SYMBOL(detach_capi_ctr);
588
589
590
591
592
593
594
595
596void register_capi_driver(struct capi_driver *driver)
597{
598 mutex_lock(&capi_drivers_lock);
599 list_add_tail(&driver->list, &capi_drivers);
600 mutex_unlock(&capi_drivers_lock);
601}
602
603EXPORT_SYMBOL(register_capi_driver);
604
605
606
607
608
609
610
611
612void unregister_capi_driver(struct capi_driver *driver)
613{
614 mutex_lock(&capi_drivers_lock);
615 list_del(&driver->list);
616 mutex_unlock(&capi_drivers_lock);
617}
618
619EXPORT_SYMBOL(unregister_capi_driver);
620
621
622
623
624
625
626
627
628
629
630
631
632u16 capi20_isinstalled(void)
633{
634 u16 ret = CAPI_REGNOTINSTALLED;
635 int i;
636
637 mutex_lock(&capi_controller_lock);
638
639 for (i = 0; i < CAPI_MAXCONTR; i++)
640 if (capi_controller[i] &&
641 capi_controller[i]->state == CAPI_CTR_RUNNING) {
642 ret = CAPI_NOERROR;
643 break;
644 }
645
646 mutex_unlock(&capi_controller_lock);
647
648 return ret;
649}
650
651EXPORT_SYMBOL(capi20_isinstalled);
652
653
654
655
656
657
658
659
660
661
662
663
664
665u16 capi20_register(struct capi20_appl *ap)
666{
667 int i;
668 u16 applid;
669
670 DBG("");
671
672 if (ap->rparam.datablklen < 128)
673 return CAPI_LOGBLKSIZETOSMALL;
674
675 ap->nrecvctlpkt = 0;
676 ap->nrecvdatapkt = 0;
677 ap->nsentctlpkt = 0;
678 ap->nsentdatapkt = 0;
679 mutex_init(&ap->recv_mtx);
680 skb_queue_head_init(&ap->recv_queue);
681 INIT_WORK(&ap->recv_work, recv_handler);
682 ap->release_in_progress = 0;
683
684 mutex_lock(&capi_controller_lock);
685
686 for (applid = 1; applid <= CAPI_MAXAPPL; applid++) {
687 if (capi_applications[applid - 1] == NULL)
688 break;
689 }
690 if (applid > CAPI_MAXAPPL) {
691 mutex_unlock(&capi_controller_lock);
692 return CAPI_TOOMANYAPPLS;
693 }
694
695 ap->applid = applid;
696 capi_applications[applid - 1] = ap;
697
698 for (i = 0; i < CAPI_MAXCONTR; i++) {
699 if (!capi_controller[i] ||
700 capi_controller[i]->state != CAPI_CTR_RUNNING)
701 continue;
702 register_appl(capi_controller[i], applid, &ap->rparam);
703 }
704
705 mutex_unlock(&capi_controller_lock);
706
707 if (showcapimsgs & 1) {
708 printk(KERN_DEBUG "kcapi: appl %d up\n", applid);
709 }
710
711 return CAPI_NOERROR;
712}
713
714EXPORT_SYMBOL(capi20_register);
715
716
717
718
719
720
721
722
723
724
725
726u16 capi20_release(struct capi20_appl *ap)
727{
728 int i;
729
730 DBG("applid %#x", ap->applid);
731
732 mutex_lock(&capi_controller_lock);
733
734 ap->release_in_progress = 1;
735 capi_applications[ap->applid - 1] = NULL;
736
737 synchronize_rcu();
738
739 for (i = 0; i < CAPI_MAXCONTR; i++) {
740 if (!capi_controller[i] ||
741 capi_controller[i]->state != CAPI_CTR_RUNNING)
742 continue;
743 release_appl(capi_controller[i], ap->applid);
744 }
745
746 mutex_unlock(&capi_controller_lock);
747
748 flush_workqueue(kcapi_wq);
749 skb_queue_purge(&ap->recv_queue);
750
751 if (showcapimsgs & 1) {
752 printk(KERN_DEBUG "kcapi: appl %d down\n", ap->applid);
753 }
754
755 return CAPI_NOERROR;
756}
757
758EXPORT_SYMBOL(capi20_release);
759
760
761
762
763
764
765
766
767
768
769u16 capi20_put_message(struct capi20_appl *ap, struct sk_buff *skb)
770{
771 struct capi_ctr *ctr;
772 int showctl = 0;
773 u8 cmd, subcmd;
774
775 DBG("applid %#x", ap->applid);
776
777 if (ncontrollers == 0)
778 return CAPI_REGNOTINSTALLED;
779 if ((ap->applid == 0) || ap->release_in_progress)
780 return CAPI_ILLAPPNR;
781 if (skb->len < 12
782 || !capi_cmd_valid(CAPIMSG_COMMAND(skb->data))
783 || !capi_subcmd_valid(CAPIMSG_SUBCOMMAND(skb->data)))
784 return CAPI_ILLCMDORSUBCMDORMSGTOSMALL;
785
786
787
788
789
790
791 ctr = get_capi_ctr_by_nr(CAPIMSG_CONTROLLER(skb->data));
792 if (!ctr || ctr->state != CAPI_CTR_RUNNING)
793 return CAPI_REGNOTINSTALLED;
794 if (ctr->blocked)
795 return CAPI_SENDQUEUEFULL;
796
797 cmd = CAPIMSG_COMMAND(skb->data);
798 subcmd = CAPIMSG_SUBCOMMAND(skb->data);
799
800 if (cmd == CAPI_DATA_B3 && subcmd == CAPI_REQ) {
801 ctr->nsentdatapkt++;
802 ap->nsentdatapkt++;
803 if (ctr->traceflag > 2)
804 showctl |= 2;
805 } else {
806 ctr->nsentctlpkt++;
807 ap->nsentctlpkt++;
808 if (ctr->traceflag)
809 showctl |= 2;
810 }
811 showctl |= (ctr->traceflag & 1);
812 if (showctl & 2) {
813 if (showctl & 1) {
814 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u\n",
815 CAPIMSG_CONTROLLER(skb->data),
816 CAPIMSG_APPID(skb->data),
817 capi_cmd2str(cmd, subcmd),
818 CAPIMSG_LEN(skb->data));
819 } else {
820 _cdebbuf *cdb = capi_message2str(skb->data);
821 if (cdb) {
822 printk(KERN_DEBUG "kcapi: put [%03d] %s\n",
823 CAPIMSG_CONTROLLER(skb->data),
824 cdb->buf);
825 cdebbuf_free(cdb);
826 } else
827 printk(KERN_DEBUG "kcapi: put [%03d] id#%d %s len=%u cannot trace\n",
828 CAPIMSG_CONTROLLER(skb->data),
829 CAPIMSG_APPID(skb->data),
830 capi_cmd2str(cmd, subcmd),
831 CAPIMSG_LEN(skb->data));
832 }
833 }
834 return ctr->send_message(ctr, skb);
835}
836
837EXPORT_SYMBOL(capi20_put_message);
838
839
840
841
842
843
844
845
846
847
848
849u16 capi20_get_manufacturer(u32 contr, u8 *buf)
850{
851 struct capi_ctr *ctr;
852 u16 ret;
853
854 if (contr == 0) {
855 strncpy(buf, capi_manufakturer, CAPI_MANUFACTURER_LEN);
856 return CAPI_NOERROR;
857 }
858
859 mutex_lock(&capi_controller_lock);
860
861 ctr = get_capi_ctr_by_nr(contr);
862 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
863 strncpy(buf, ctr->manu, CAPI_MANUFACTURER_LEN);
864 ret = CAPI_NOERROR;
865 } else
866 ret = CAPI_REGNOTINSTALLED;
867
868 mutex_unlock(&capi_controller_lock);
869 return ret;
870}
871
872EXPORT_SYMBOL(capi20_get_manufacturer);
873
874
875
876
877
878
879
880
881
882
883
884u16 capi20_get_version(u32 contr, struct capi_version *verp)
885{
886 struct capi_ctr *ctr;
887 u16 ret;
888
889 if (contr == 0) {
890 *verp = driver_version;
891 return CAPI_NOERROR;
892 }
893
894 mutex_lock(&capi_controller_lock);
895
896 ctr = get_capi_ctr_by_nr(contr);
897 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
898 memcpy(verp, &ctr->version, sizeof(capi_version));
899 ret = CAPI_NOERROR;
900 } else
901 ret = CAPI_REGNOTINSTALLED;
902
903 mutex_unlock(&capi_controller_lock);
904 return ret;
905}
906
907EXPORT_SYMBOL(capi20_get_version);
908
909
910
911
912
913
914
915
916
917
918
919u16 capi20_get_serial(u32 contr, u8 *serial)
920{
921 struct capi_ctr *ctr;
922 u16 ret;
923
924 if (contr == 0) {
925 strlcpy(serial, driver_serial, CAPI_SERIAL_LEN);
926 return CAPI_NOERROR;
927 }
928
929 mutex_lock(&capi_controller_lock);
930
931 ctr = get_capi_ctr_by_nr(contr);
932 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
933 strlcpy(serial, ctr->serial, CAPI_SERIAL_LEN);
934 ret = CAPI_NOERROR;
935 } else
936 ret = CAPI_REGNOTINSTALLED;
937
938 mutex_unlock(&capi_controller_lock);
939 return ret;
940}
941
942EXPORT_SYMBOL(capi20_get_serial);
943
944
945
946
947
948
949
950
951
952
953
954u16 capi20_get_profile(u32 contr, struct capi_profile *profp)
955{
956 struct capi_ctr *ctr;
957 u16 ret;
958
959 if (contr == 0) {
960 profp->ncontroller = ncontrollers;
961 return CAPI_NOERROR;
962 }
963
964 mutex_lock(&capi_controller_lock);
965
966 ctr = get_capi_ctr_by_nr(contr);
967 if (ctr && ctr->state == CAPI_CTR_RUNNING) {
968 memcpy(profp, &ctr->profile, sizeof(struct capi_profile));
969 ret = CAPI_NOERROR;
970 } else
971 ret = CAPI_REGNOTINSTALLED;
972
973 mutex_unlock(&capi_controller_lock);
974 return ret;
975}
976
977EXPORT_SYMBOL(capi20_get_profile);
978
979
980static int wait_on_ctr_state(struct capi_ctr *ctr, unsigned int state)
981{
982 DEFINE_WAIT(wait);
983 int retval = 0;
984
985 ctr = capi_ctr_get(ctr);
986 if (!ctr)
987 return -ESRCH;
988
989 for (;;) {
990 prepare_to_wait(&ctr->state_wait_queue, &wait,
991 TASK_INTERRUPTIBLE);
992
993 if (ctr->state == state)
994 break;
995 if (ctr->state == CAPI_CTR_DETACHED) {
996 retval = -ESRCH;
997 break;
998 }
999 if (signal_pending(current)) {
1000 retval = -EINTR;
1001 break;
1002 }
1003
1004 mutex_unlock(&capi_controller_lock);
1005 schedule();
1006 mutex_lock(&capi_controller_lock);
1007 }
1008 finish_wait(&ctr->state_wait_queue, &wait);
1009
1010 capi_ctr_put(ctr);
1011
1012 return retval;
1013}
1014
1015#ifdef AVMB1_COMPAT
1016static int old_capi_manufacturer(unsigned int cmd, void __user *data)
1017{
1018 avmb1_loadandconfigdef ldef;
1019 avmb1_extcarddef cdef;
1020 avmb1_resetdef rdef;
1021 capicardparams cparams;
1022 struct capi_ctr *ctr;
1023 struct capi_driver *driver = NULL;
1024 capiloaddata ldata;
1025 struct list_head *l;
1026 int retval;
1027
1028 switch (cmd) {
1029 case AVMB1_ADDCARD:
1030 case AVMB1_ADDCARD_WITH_TYPE:
1031 if (cmd == AVMB1_ADDCARD) {
1032 if ((retval = copy_from_user(&cdef, data,
1033 sizeof(avmb1_carddef))))
1034 return -EFAULT;
1035 cdef.cardtype = AVM_CARDTYPE_B1;
1036 cdef.cardnr = 0;
1037 } else {
1038 if ((retval = copy_from_user(&cdef, data,
1039 sizeof(avmb1_extcarddef))))
1040 return -EFAULT;
1041 }
1042 cparams.port = cdef.port;
1043 cparams.irq = cdef.irq;
1044 cparams.cardnr = cdef.cardnr;
1045
1046 mutex_lock(&capi_drivers_lock);
1047
1048 switch (cdef.cardtype) {
1049 case AVM_CARDTYPE_B1:
1050 list_for_each(l, &capi_drivers) {
1051 driver = list_entry(l, struct capi_driver, list);
1052 if (strcmp(driver->name, "b1isa") == 0)
1053 break;
1054 }
1055 break;
1056 case AVM_CARDTYPE_T1:
1057 list_for_each(l, &capi_drivers) {
1058 driver = list_entry(l, struct capi_driver, list);
1059 if (strcmp(driver->name, "t1isa") == 0)
1060 break;
1061 }
1062 break;
1063 default:
1064 driver = NULL;
1065 break;
1066 }
1067 if (!driver) {
1068 printk(KERN_ERR "kcapi: driver not loaded.\n");
1069 retval = -EIO;
1070 } else if (!driver->add_card) {
1071 printk(KERN_ERR "kcapi: driver has no add card function.\n");
1072 retval = -EIO;
1073 } else
1074 retval = driver->add_card(driver, &cparams);
1075
1076 mutex_unlock(&capi_drivers_lock);
1077 return retval;
1078
1079 case AVMB1_LOAD:
1080 case AVMB1_LOAD_AND_CONFIG:
1081
1082 if (cmd == AVMB1_LOAD) {
1083 if (copy_from_user(&ldef, data,
1084 sizeof(avmb1_loaddef)))
1085 return -EFAULT;
1086 ldef.t4config.len = 0;
1087 ldef.t4config.data = NULL;
1088 } else {
1089 if (copy_from_user(&ldef, data,
1090 sizeof(avmb1_loadandconfigdef)))
1091 return -EFAULT;
1092 }
1093
1094 mutex_lock(&capi_controller_lock);
1095
1096 ctr = get_capi_ctr_by_nr(ldef.contr);
1097 if (!ctr) {
1098 retval = -EINVAL;
1099 goto load_unlock_out;
1100 }
1101
1102 if (ctr->load_firmware == NULL) {
1103 printk(KERN_DEBUG "kcapi: load: no load function\n");
1104 retval = -ESRCH;
1105 goto load_unlock_out;
1106 }
1107
1108 if (ldef.t4file.len <= 0) {
1109 printk(KERN_DEBUG "kcapi: load: invalid parameter: length of t4file is %d ?\n", ldef.t4file.len);
1110 retval = -EINVAL;
1111 goto load_unlock_out;
1112 }
1113 if (ldef.t4file.data == NULL) {
1114 printk(KERN_DEBUG "kcapi: load: invalid parameter: dataptr is 0\n");
1115 retval = -EINVAL;
1116 goto load_unlock_out;
1117 }
1118
1119 ldata.firmware.user = 1;
1120 ldata.firmware.data = ldef.t4file.data;
1121 ldata.firmware.len = ldef.t4file.len;
1122 ldata.configuration.user = 1;
1123 ldata.configuration.data = ldef.t4config.data;
1124 ldata.configuration.len = ldef.t4config.len;
1125
1126 if (ctr->state != CAPI_CTR_DETECTED) {
1127 printk(KERN_INFO "kcapi: load: contr=%d not in detect state\n", ldef.contr);
1128 retval = -EBUSY;
1129 goto load_unlock_out;
1130 }
1131 ctr->state = CAPI_CTR_LOADING;
1132
1133 retval = ctr->load_firmware(ctr, &ldata);
1134 if (retval) {
1135 ctr->state = CAPI_CTR_DETECTED;
1136 goto load_unlock_out;
1137 }
1138
1139 retval = wait_on_ctr_state(ctr, CAPI_CTR_RUNNING);
1140
1141 load_unlock_out:
1142 mutex_unlock(&capi_controller_lock);
1143 return retval;
1144
1145 case AVMB1_RESETCARD:
1146 if (copy_from_user(&rdef, data, sizeof(avmb1_resetdef)))
1147 return -EFAULT;
1148
1149 retval = 0;
1150
1151 mutex_lock(&capi_controller_lock);
1152
1153 ctr = get_capi_ctr_by_nr(rdef.contr);
1154 if (!ctr) {
1155 retval = -ESRCH;
1156 goto reset_unlock_out;
1157 }
1158
1159 if (ctr->state == CAPI_CTR_DETECTED)
1160 goto reset_unlock_out;
1161
1162 if (ctr->reset_ctr == NULL) {
1163 printk(KERN_DEBUG "kcapi: reset: no reset function\n");
1164 retval = -ESRCH;
1165 goto reset_unlock_out;
1166 }
1167
1168 ctr->reset_ctr(ctr);
1169
1170 retval = wait_on_ctr_state(ctr, CAPI_CTR_DETECTED);
1171
1172 reset_unlock_out:
1173 mutex_unlock(&capi_controller_lock);
1174 return retval;
1175 }
1176 return -EINVAL;
1177}
1178#endif
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189int capi20_manufacturer(unsigned long cmd, void __user *data)
1190{
1191 struct capi_ctr *ctr;
1192 int retval;
1193
1194 switch (cmd) {
1195#ifdef AVMB1_COMPAT
1196 case AVMB1_LOAD:
1197 case AVMB1_LOAD_AND_CONFIG:
1198 case AVMB1_RESETCARD:
1199 case AVMB1_GET_CARDINFO:
1200 case AVMB1_REMOVECARD:
1201 return old_capi_manufacturer(cmd, data);
1202#endif
1203 case KCAPI_CMD_TRACE:
1204 {
1205 kcapi_flagdef fdef;
1206
1207 if (copy_from_user(&fdef, data, sizeof(kcapi_flagdef)))
1208 return -EFAULT;
1209
1210 mutex_lock(&capi_controller_lock);
1211
1212 ctr = get_capi_ctr_by_nr(fdef.contr);
1213 if (ctr) {
1214 ctr->traceflag = fdef.flag;
1215 printk(KERN_INFO "kcapi: contr [%03d] set trace=%d\n",
1216 ctr->cnr, ctr->traceflag);
1217 retval = 0;
1218 } else
1219 retval = -ESRCH;
1220
1221 mutex_unlock(&capi_controller_lock);
1222
1223 return retval;
1224 }
1225 case KCAPI_CMD_ADDCARD:
1226 {
1227 struct list_head *l;
1228 struct capi_driver *driver = NULL;
1229 capicardparams cparams;
1230 kcapi_carddef cdef;
1231
1232 if ((retval = copy_from_user(&cdef, data, sizeof(cdef))))
1233 return -EFAULT;
1234
1235 cparams.port = cdef.port;
1236 cparams.irq = cdef.irq;
1237 cparams.membase = cdef.membase;
1238 cparams.cardnr = cdef.cardnr;
1239 cparams.cardtype = 0;
1240 cdef.driver[sizeof(cdef.driver) - 1] = 0;
1241
1242 mutex_lock(&capi_drivers_lock);
1243
1244 list_for_each(l, &capi_drivers) {
1245 driver = list_entry(l, struct capi_driver, list);
1246 if (strcmp(driver->name, cdef.driver) == 0)
1247 break;
1248 }
1249 if (driver == NULL) {
1250 printk(KERN_ERR "kcapi: driver \"%s\" not loaded.\n",
1251 cdef.driver);
1252 retval = -ESRCH;
1253 } else if (!driver->add_card) {
1254 printk(KERN_ERR "kcapi: driver \"%s\" has no add card function.\n", cdef.driver);
1255 retval = -EIO;
1256 } else
1257 retval = driver->add_card(driver, &cparams);
1258
1259 mutex_unlock(&capi_drivers_lock);
1260 return retval;
1261 }
1262
1263 default:
1264 printk(KERN_ERR "kcapi: manufacturer command %lu unknown.\n",
1265 cmd);
1266 break;
1267
1268 }
1269 return -EINVAL;
1270}
1271
1272EXPORT_SYMBOL(capi20_manufacturer);
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282static struct notifier_block capictr_nb = {
1283 .notifier_call = notify_handler,
1284 .priority = INT_MAX,
1285};
1286
1287static int __init kcapi_init(void)
1288{
1289 int err;
1290
1291 kcapi_wq = alloc_workqueue("kcapi", 0, 0);
1292 if (!kcapi_wq)
1293 return -ENOMEM;
1294
1295 register_capictr_notifier(&capictr_nb);
1296
1297 err = cdebug_init();
1298 if (err) {
1299 unregister_capictr_notifier(&capictr_nb);
1300 destroy_workqueue(kcapi_wq);
1301 return err;
1302 }
1303
1304 kcapi_proc_init();
1305 return 0;
1306}
1307
1308static void __exit kcapi_exit(void)
1309{
1310 kcapi_proc_exit();
1311
1312 unregister_capictr_notifier(&capictr_nb);
1313 cdebug_exit();
1314 destroy_workqueue(kcapi_wq);
1315}
1316
1317module_init(kcapi_init);
1318module_exit(kcapi_exit);
1319
