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