Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/shaggy...
[linux-2.6] / drivers / isdn / capi / capidrv.c
1 /* $Id: capidrv.c,v 1.1.2.2 2004/01/12 23:17:24 keil Exp $
2  *
3  * ISDN4Linux Driver, using capi20 interface (kernelcapi)
4  *
5  * Copyright 1997 by Carsten Paeth <calle@calle.de>
6  *
7  * This software may be used and distributed according to the terms
8  * of the GNU General Public License, incorporated herein by reference.
9  *
10  */
11
12 #include <linux/module.h>
13 #include <linux/errno.h>
14 #include <linux/kernel.h>
15 #include <linux/major.h>
16 #include <linux/sched.h>
17 #include <linux/slab.h>
18 #include <linux/fcntl.h>
19 #include <linux/fs.h>
20 #include <linux/signal.h>
21 #include <linux/mm.h>
22 #include <linux/timer.h>
23 #include <linux/wait.h>
24 #include <linux/skbuff.h>
25 #include <linux/isdn.h>
26 #include <linux/isdnif.h>
27 #include <linux/proc_fs.h>
28 #include <linux/capi.h>
29 #include <linux/kernelcapi.h>
30 #include <linux/ctype.h>
31 #include <linux/init.h>
32 #include <linux/moduleparam.h>
33
34 #include <linux/isdn/capiutil.h>
35 #include <linux/isdn/capicmd.h>
36 #include "capidrv.h"
37
38 static char *revision = "$Revision: 1.1.2.2 $";
39 static int debugmode = 0;
40
41 MODULE_DESCRIPTION("CAPI4Linux: Interface to ISDN4Linux");
42 MODULE_AUTHOR("Carsten Paeth");
43 MODULE_LICENSE("GPL");
44 module_param(debugmode, uint, 0);
45
46 /* -------- type definitions ----------------------------------------- */
47
48
49 struct capidrv_contr {
50
51         struct capidrv_contr *next;
52         struct module *owner;
53         u32 contrnr;
54         char name[20];
55
56         /*
57          * for isdn4linux
58          */
59         isdn_if interface;
60         int myid;
61
62         /*
63          * LISTEN state
64          */
65         int state;
66         u32 cipmask;
67         u32 cipmask2;
68         struct timer_list listentimer;
69
70         /*
71          * ID of capi message sent
72          */
73         u16 msgid;
74
75         /*
76          * B-Channels
77          */
78         int nbchan;
79         struct capidrv_bchan {
80                 struct capidrv_contr *contr;
81                 u8 msn[ISDN_MSNLEN];
82                 int l2;
83                 int l3;
84                 u8 num[ISDN_MSNLEN];
85                 u8 mynum[ISDN_MSNLEN];
86                 int si1;
87                 int si2;
88                 int incoming;
89                 int disconnecting;
90                 struct capidrv_plci {
91                         struct capidrv_plci *next;
92                         u32 plci;
93                         u32 ncci;       /* ncci for CONNECT_ACTIVE_IND */
94                         u16 msgid;      /* to identfy CONNECT_CONF */
95                         int chan;
96                         int state;
97                         int leasedline;
98                         struct capidrv_ncci {
99                                 struct capidrv_ncci *next;
100                                 struct capidrv_plci *plcip;
101                                 u32 ncci;
102                                 u16 msgid;      /* to identfy CONNECT_B3_CONF */
103                                 int chan;
104                                 int state;
105                                 int oldstate;
106                                 /* */
107                                 u16 datahandle;
108                                 struct ncci_datahandle_queue {
109                                     struct ncci_datahandle_queue *next;
110                                     u16                         datahandle;
111                                     int                           len;
112                                 } *ackqueue;
113                         } *ncci_list;
114                 } *plcip;
115                 struct capidrv_ncci *nccip;
116         } *bchans;
117
118         struct capidrv_plci *plci_list;
119
120         /* for q931 data */
121         u8  q931_buf[4096];
122         u8 *q931_read;
123         u8 *q931_write;
124         u8 *q931_end;
125 };
126
127
128 struct capidrv_data {
129         struct capi20_appl ap;
130         int ncontr;
131         struct capidrv_contr *contr_list;
132 };
133
134 typedef struct capidrv_plci capidrv_plci;
135 typedef struct capidrv_ncci capidrv_ncci;
136 typedef struct capidrv_contr capidrv_contr;
137 typedef struct capidrv_data capidrv_data;
138 typedef struct capidrv_bchan capidrv_bchan;
139
140 /* -------- data definitions ----------------------------------------- */
141
142 static capidrv_data global;
143 static DEFINE_SPINLOCK(global_lock);
144
145 static void handle_dtrace_data(capidrv_contr *card,
146         int send, int level2, u8 *data, u16 len);
147
148 /* -------- convert functions ---------------------------------------- */
149
150 static inline u32 b1prot(int l2, int l3)
151 {
152         switch (l2) {
153         case ISDN_PROTO_L2_X75I:
154         case ISDN_PROTO_L2_X75UI:
155         case ISDN_PROTO_L2_X75BUI:
156                 return 0;
157         case ISDN_PROTO_L2_HDLC:
158         default:
159                 return 0;
160         case ISDN_PROTO_L2_TRANS:
161                 return 1;
162         case ISDN_PROTO_L2_V11096:
163         case ISDN_PROTO_L2_V11019:
164         case ISDN_PROTO_L2_V11038:
165                 return 2;
166         case ISDN_PROTO_L2_FAX:
167                 return 4;
168         case ISDN_PROTO_L2_MODEM:
169                 return 8;
170         }
171 }
172
173 static inline u32 b2prot(int l2, int l3)
174 {
175         switch (l2) {
176         case ISDN_PROTO_L2_X75I:
177         case ISDN_PROTO_L2_X75UI:
178         case ISDN_PROTO_L2_X75BUI:
179         default:
180                 return 0;
181         case ISDN_PROTO_L2_HDLC:
182         case ISDN_PROTO_L2_TRANS:
183         case ISDN_PROTO_L2_V11096:
184         case ISDN_PROTO_L2_V11019:
185         case ISDN_PROTO_L2_V11038:
186         case ISDN_PROTO_L2_MODEM:
187                 return 1;
188         case ISDN_PROTO_L2_FAX:
189                 return 4;
190         }
191 }
192
193 static inline u32 b3prot(int l2, int l3)
194 {
195         switch (l2) {
196         case ISDN_PROTO_L2_X75I:
197         case ISDN_PROTO_L2_X75UI:
198         case ISDN_PROTO_L2_X75BUI:
199         case ISDN_PROTO_L2_HDLC:
200         case ISDN_PROTO_L2_TRANS:
201         case ISDN_PROTO_L2_V11096:
202         case ISDN_PROTO_L2_V11019:
203         case ISDN_PROTO_L2_V11038:
204         case ISDN_PROTO_L2_MODEM:
205         default:
206                 return 0;
207         case ISDN_PROTO_L2_FAX:
208                 return 4;
209         }
210 }
211
212 static _cstruct b1config_async_v110(u16 rate)
213 {
214         /* CAPI-Spec "B1 Configuration" */
215         static unsigned char buf[9];
216         buf[0] = 8; /* len */
217         /* maximum bitrate */
218         buf[1] = rate & 0xff; buf[2] = (rate >> 8) & 0xff;
219         buf[3] = 8; buf[4] = 0; /* 8 bits per character */
220         buf[5] = 0; buf[6] = 0; /* parity none */
221         buf[7] = 0; buf[8] = 0; /* 1 stop bit */
222         return buf;
223 }
224
225 static _cstruct b1config(int l2, int l3)
226 {
227         switch (l2) {
228         case ISDN_PROTO_L2_X75I:
229         case ISDN_PROTO_L2_X75UI:
230         case ISDN_PROTO_L2_X75BUI:
231         case ISDN_PROTO_L2_HDLC:
232         case ISDN_PROTO_L2_TRANS:
233         default:
234                 return NULL;
235         case ISDN_PROTO_L2_V11096:
236             return b1config_async_v110(9600);
237         case ISDN_PROTO_L2_V11019:
238             return b1config_async_v110(19200);
239         case ISDN_PROTO_L2_V11038:
240             return b1config_async_v110(38400);
241         }
242 }
243
244 static inline u16 si2cip(u8 si1, u8 si2)
245 {
246         static const u8 cip[17][5] =
247         {
248         /*  0  1  2  3  4  */
249                 {0, 0, 0, 0, 0},        /*0 */
250                 {16, 16, 4, 26, 16},    /*1 */
251                 {17, 17, 17, 4, 4},     /*2 */
252                 {2, 2, 2, 2, 2},        /*3 */
253                 {18, 18, 18, 18, 18},   /*4 */
254                 {2, 2, 2, 2, 2},        /*5 */
255                 {0, 0, 0, 0, 0},        /*6 */
256                 {2, 2, 2, 2, 2},        /*7 */
257                 {2, 2, 2, 2, 2},        /*8 */
258                 {21, 21, 21, 21, 21},   /*9 */
259                 {19, 19, 19, 19, 19},   /*10 */
260                 {0, 0, 0, 0, 0},        /*11 */
261                 {0, 0, 0, 0, 0},        /*12 */
262                 {0, 0, 0, 0, 0},        /*13 */
263                 {0, 0, 0, 0, 0},        /*14 */
264                 {22, 22, 22, 22, 22},   /*15 */
265                 {27, 27, 27, 28, 27}    /*16 */
266         };
267         if (si1 > 16)
268                 si1 = 0;
269         if (si2 > 4)
270                 si2 = 0;
271
272         return (u16) cip[si1][si2];
273 }
274
275 static inline u8 cip2si1(u16 cipval)
276 {
277         static const u8 si[32] =
278         {7, 1, 7, 7, 1, 1, 7, 7,        /*0-7 */
279          7, 1, 0, 0, 0, 0, 0, 0,        /*8-15 */
280          1, 2, 4, 10, 9, 9, 15, 7,      /*16-23 */
281          7, 7, 1, 16, 16, 0, 0, 0};     /*24-31 */
282
283         if (cipval > 31)
284                 cipval = 0;     /* .... */
285         return si[cipval];
286 }
287
288 static inline u8 cip2si2(u16 cipval)
289 {
290         static const u8 si[32] =
291         {0, 0, 0, 0, 2, 3, 0, 0,        /*0-7 */
292          0, 3, 0, 0, 0, 0, 0, 0,        /*8-15 */
293          1, 2, 0, 0, 9, 0, 0, 0,        /*16-23 */
294          0, 0, 3, 2, 3, 0, 0, 0};       /*24-31 */
295
296         if (cipval > 31)
297                 cipval = 0;     /* .... */
298         return si[cipval];
299 }
300
301
302 /* -------- controller management ------------------------------------- */
303
304 static inline capidrv_contr *findcontrbydriverid(int driverid)
305 {
306         unsigned long flags;
307         capidrv_contr *p;
308
309         spin_lock_irqsave(&global_lock, flags);
310         for (p = global.contr_list; p; p = p->next)
311                 if (p->myid == driverid)
312                         break;
313         spin_unlock_irqrestore(&global_lock, flags);
314         return p;
315 }
316
317 static capidrv_contr *findcontrbynumber(u32 contr)
318 {
319         unsigned long flags;
320         capidrv_contr *p = global.contr_list;
321
322         spin_lock_irqsave(&global_lock, flags);
323         for (p = global.contr_list; p; p = p->next)
324                 if (p->contrnr == contr)
325                         break;
326         spin_unlock_irqrestore(&global_lock, flags);
327         return p;
328 }
329
330
331 /* -------- plci management ------------------------------------------ */
332
333 static capidrv_plci *new_plci(capidrv_contr * card, int chan)
334 {
335         capidrv_plci *plcip;
336
337         plcip = kzalloc(sizeof(capidrv_plci), GFP_ATOMIC);
338
339         if (plcip == 0)
340                 return NULL;
341
342         plcip->state = ST_PLCI_NONE;
343         plcip->plci = 0;
344         plcip->msgid = 0;
345         plcip->chan = chan;
346         plcip->next = card->plci_list;
347         card->plci_list = plcip;
348         card->bchans[chan].plcip = plcip;
349
350         return plcip;
351 }
352
353 static capidrv_plci *find_plci_by_plci(capidrv_contr * card, u32 plci)
354 {
355         capidrv_plci *p;
356         for (p = card->plci_list; p; p = p->next)
357                 if (p->plci == plci)
358                         return p;
359         return NULL;
360 }
361
362 static capidrv_plci *find_plci_by_msgid(capidrv_contr * card, u16 msgid)
363 {
364         capidrv_plci *p;
365         for (p = card->plci_list; p; p = p->next)
366                 if (p->msgid == msgid)
367                         return p;
368         return NULL;
369 }
370
371 static capidrv_plci *find_plci_by_ncci(capidrv_contr * card, u32 ncci)
372 {
373         capidrv_plci *p;
374         for (p = card->plci_list; p; p = p->next)
375                 if (p->plci == (ncci & 0xffff))
376                         return p;
377         return NULL;
378 }
379
380 static void free_plci(capidrv_contr * card, capidrv_plci * plcip)
381 {
382         capidrv_plci **pp;
383
384         for (pp = &card->plci_list; *pp; pp = &(*pp)->next) {
385                 if (*pp == plcip) {
386                         *pp = (*pp)->next;
387                         card->bchans[plcip->chan].plcip = NULL;
388                         card->bchans[plcip->chan].disconnecting = 0;
389                         card->bchans[plcip->chan].incoming = 0;
390                         kfree(plcip);
391                         return;
392                 }
393         }
394         printk(KERN_ERR "capidrv-%d: free_plci %p (0x%x) not found, Huh?\n",
395                card->contrnr, plcip, plcip->plci);
396 }
397
398 /* -------- ncci management ------------------------------------------ */
399
400 static inline capidrv_ncci *new_ncci(capidrv_contr * card,
401                                      capidrv_plci * plcip,
402                                      u32 ncci)
403 {
404         capidrv_ncci *nccip;
405
406         nccip = kzalloc(sizeof(capidrv_ncci), GFP_ATOMIC);
407
408         if (nccip == 0)
409                 return NULL;
410
411         nccip->ncci = ncci;
412         nccip->state = ST_NCCI_NONE;
413         nccip->plcip = plcip;
414         nccip->chan = plcip->chan;
415         nccip->datahandle = 0;
416
417         nccip->next = plcip->ncci_list;
418         plcip->ncci_list = nccip;
419
420         card->bchans[plcip->chan].nccip = nccip;
421
422         return nccip;
423 }
424
425 static inline capidrv_ncci *find_ncci(capidrv_contr * card, u32 ncci)
426 {
427         capidrv_plci *plcip;
428         capidrv_ncci *p;
429
430         if ((plcip = find_plci_by_ncci(card, ncci)) == 0)
431                 return NULL;
432
433         for (p = plcip->ncci_list; p; p = p->next)
434                 if (p->ncci == ncci)
435                         return p;
436         return NULL;
437 }
438
439 static inline capidrv_ncci *find_ncci_by_msgid(capidrv_contr * card,
440                                                u32 ncci, u16 msgid)
441 {
442         capidrv_plci *plcip;
443         capidrv_ncci *p;
444
445         if ((plcip = find_plci_by_ncci(card, ncci)) == 0)
446                 return NULL;
447
448         for (p = plcip->ncci_list; p; p = p->next)
449                 if (p->msgid == msgid)
450                         return p;
451         return NULL;
452 }
453
454 static void free_ncci(capidrv_contr * card, struct capidrv_ncci *nccip)
455 {
456         struct capidrv_ncci **pp;
457
458         for (pp = &(nccip->plcip->ncci_list); *pp; pp = &(*pp)->next) {
459                 if (*pp == nccip) {
460                         *pp = (*pp)->next;
461                         break;
462                 }
463         }
464         card->bchans[nccip->chan].nccip = NULL;
465         kfree(nccip);
466 }
467
468 static int capidrv_add_ack(struct capidrv_ncci *nccip,
469                            u16 datahandle, int len)
470 {
471         struct ncci_datahandle_queue *n, **pp;
472
473         n = (struct ncci_datahandle_queue *)
474                 kmalloc(sizeof(struct ncci_datahandle_queue), GFP_ATOMIC);
475         if (!n) {
476            printk(KERN_ERR "capidrv: kmalloc ncci_datahandle failed\n");
477            return -1;
478         }
479         n->next = NULL;
480         n->datahandle = datahandle;
481         n->len = len;
482         for (pp = &nccip->ackqueue; *pp; pp = &(*pp)->next) ;
483         *pp = n;
484         return 0;
485 }
486
487 static int capidrv_del_ack(struct capidrv_ncci *nccip, u16 datahandle)
488 {
489         struct ncci_datahandle_queue **pp, *p;
490         int len;
491
492         for (pp = &nccip->ackqueue; *pp; pp = &(*pp)->next) {
493                 if ((*pp)->datahandle == datahandle) {
494                         p = *pp;
495                         len = p->len;
496                         *pp = (*pp)->next;
497                         kfree(p);
498                         return len;
499                 }
500         }
501         return -1;
502 }
503
504 /* -------- convert and send capi message ---------------------------- */
505
506 static void send_message(capidrv_contr * card, _cmsg * cmsg)
507 {
508         struct sk_buff *skb;
509         size_t len;
510         capi_cmsg2message(cmsg, cmsg->buf);
511         len = CAPIMSG_LEN(cmsg->buf);
512         skb = alloc_skb(len, GFP_ATOMIC);
513         memcpy(skb_put(skb, len), cmsg->buf, len);
514         if (capi20_put_message(&global.ap, skb) != CAPI_NOERROR)
515                 kfree_skb(skb);
516 }
517
518 /* -------- state machine -------------------------------------------- */
519
520 struct listenstatechange {
521         int actstate;
522         int nextstate;
523         int event;
524 };
525
526 static struct listenstatechange listentable[] =
527 {
528   {ST_LISTEN_NONE, ST_LISTEN_WAIT_CONF, EV_LISTEN_REQ},
529   {ST_LISTEN_ACTIVE, ST_LISTEN_ACTIVE_WAIT_CONF, EV_LISTEN_REQ},
530   {ST_LISTEN_WAIT_CONF, ST_LISTEN_NONE, EV_LISTEN_CONF_ERROR},
531   {ST_LISTEN_ACTIVE_WAIT_CONF, ST_LISTEN_ACTIVE, EV_LISTEN_CONF_ERROR},
532   {ST_LISTEN_WAIT_CONF, ST_LISTEN_NONE, EV_LISTEN_CONF_EMPTY},
533   {ST_LISTEN_ACTIVE_WAIT_CONF, ST_LISTEN_NONE, EV_LISTEN_CONF_EMPTY},
534   {ST_LISTEN_WAIT_CONF, ST_LISTEN_ACTIVE, EV_LISTEN_CONF_OK},
535   {ST_LISTEN_ACTIVE_WAIT_CONF, ST_LISTEN_ACTIVE, EV_LISTEN_CONF_OK},
536   {},
537 };
538
539 static void listen_change_state(capidrv_contr * card, int event)
540 {
541         struct listenstatechange *p = listentable;
542         while (p->event) {
543                 if (card->state == p->actstate && p->event == event) {
544                         if (debugmode)
545                                 printk(KERN_DEBUG "capidrv-%d: listen_change_state %d -> %d\n",
546                                        card->contrnr, card->state, p->nextstate);
547                         card->state = p->nextstate;
548                         return;
549                 }
550                 p++;
551         }
552         printk(KERN_ERR "capidrv-%d: listen_change_state state=%d event=%d ????\n",
553                card->contrnr, card->state, event);
554
555 }
556
557 /* ------------------------------------------------------------------ */
558
559 static void p0(capidrv_contr * card, capidrv_plci * plci)
560 {
561         isdn_ctrl cmd;
562
563         card->bchans[plci->chan].contr = NULL;
564         cmd.command = ISDN_STAT_DHUP;
565         cmd.driver = card->myid;
566         cmd.arg = plci->chan;
567         card->interface.statcallb(&cmd);
568         free_plci(card, plci);
569 }
570
571 /* ------------------------------------------------------------------ */
572
573 struct plcistatechange {
574         int actstate;
575         int nextstate;
576         int event;
577         void (*changefunc) (capidrv_contr * card, capidrv_plci * plci);
578 };
579
580 static struct plcistatechange plcitable[] =
581 {
582   /* P-0 */
583   {ST_PLCI_NONE, ST_PLCI_OUTGOING, EV_PLCI_CONNECT_REQ, NULL},
584   {ST_PLCI_NONE, ST_PLCI_ALLOCATED, EV_PLCI_FACILITY_IND_UP, NULL},
585   {ST_PLCI_NONE, ST_PLCI_INCOMING, EV_PLCI_CONNECT_IND, NULL},
586   {ST_PLCI_NONE, ST_PLCI_RESUMEING, EV_PLCI_RESUME_REQ, NULL},
587   /* P-0.1 */
588   {ST_PLCI_OUTGOING, ST_PLCI_NONE, EV_PLCI_CONNECT_CONF_ERROR, p0},
589   {ST_PLCI_OUTGOING, ST_PLCI_ALLOCATED, EV_PLCI_CONNECT_CONF_OK, NULL},
590   /* P-1 */
591   {ST_PLCI_ALLOCATED, ST_PLCI_ACTIVE, EV_PLCI_CONNECT_ACTIVE_IND, NULL},
592   {ST_PLCI_ALLOCATED, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, NULL},
593   {ST_PLCI_ALLOCATED, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, NULL},
594   {ST_PLCI_ALLOCATED, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
595   /* P-ACT */
596   {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, NULL},
597   {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, NULL},
598   {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
599   {ST_PLCI_ACTIVE, ST_PLCI_HELD, EV_PLCI_HOLD_IND, NULL},
600   {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTING, EV_PLCI_SUSPEND_IND, NULL},
601   /* P-2 */
602   {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_CONNECT_REJECT, NULL},
603   {ST_PLCI_INCOMING, ST_PLCI_FACILITY_IND, EV_PLCI_FACILITY_IND_UP, NULL},
604   {ST_PLCI_INCOMING, ST_PLCI_ACCEPTING, EV_PLCI_CONNECT_RESP, NULL},
605   {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, NULL},
606   {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, NULL},
607   {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
608   {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_CD_IND, NULL},
609   /* P-3 */
610   {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTING, EV_PLCI_CONNECT_REJECT, NULL},
611   {ST_PLCI_FACILITY_IND, ST_PLCI_ACCEPTING, EV_PLCI_CONNECT_ACTIVE_IND, NULL},
612   {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, NULL},
613   {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, NULL},
614   {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
615   /* P-4 */
616   {ST_PLCI_ACCEPTING, ST_PLCI_ACTIVE, EV_PLCI_CONNECT_ACTIVE_IND, NULL},
617   {ST_PLCI_ACCEPTING, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, NULL},
618   {ST_PLCI_ACCEPTING, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, NULL},
619   {ST_PLCI_ACCEPTING, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
620   /* P-5 */
621   {ST_PLCI_DISCONNECTING, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
622   /* P-6 */
623   {ST_PLCI_DISCONNECTED, ST_PLCI_NONE, EV_PLCI_DISCONNECT_RESP, p0},
624   /* P-0.Res */
625   {ST_PLCI_RESUMEING, ST_PLCI_NONE, EV_PLCI_RESUME_CONF_ERROR, p0},
626   {ST_PLCI_RESUMEING, ST_PLCI_RESUME, EV_PLCI_RESUME_CONF_OK, NULL},
627   /* P-RES */
628   {ST_PLCI_RESUME, ST_PLCI_ACTIVE, EV_PLCI_RESUME_IND, NULL},
629   /* P-HELD */
630   {ST_PLCI_HELD, ST_PLCI_ACTIVE, EV_PLCI_RETRIEVE_IND, NULL},
631   {},
632 };
633
634 static void plci_change_state(capidrv_contr * card, capidrv_plci * plci, int event)
635 {
636         struct plcistatechange *p = plcitable;
637         while (p->event) {
638                 if (plci->state == p->actstate && p->event == event) {
639                         if (debugmode)
640                                 printk(KERN_DEBUG "capidrv-%d: plci_change_state:0x%x %d -> %d\n",
641                                   card->contrnr, plci->plci, plci->state, p->nextstate);
642                         plci->state = p->nextstate;
643                         if (p->changefunc)
644                                 p->changefunc(card, plci);
645                         return;
646                 }
647                 p++;
648         }
649         printk(KERN_ERR "capidrv-%d: plci_change_state:0x%x state=%d event=%d ????\n",
650                card->contrnr, plci->plci, plci->state, event);
651 }
652
653 /* ------------------------------------------------------------------ */
654
655 static _cmsg cmsg;
656
657 static void n0(capidrv_contr * card, capidrv_ncci * ncci)
658 {
659         isdn_ctrl cmd;
660
661         capi_fill_DISCONNECT_REQ(&cmsg,
662                                  global.ap.applid,
663                                  card->msgid++,
664                                  ncci->plcip->plci,
665                                  NULL,  /* BChannelinformation */
666                                  NULL,  /* Keypadfacility */
667                                  NULL,  /* Useruserdata */   /* $$$$ */
668                                  NULL   /* Facilitydataarray */
669         );
670         send_message(card, &cmsg);
671         plci_change_state(card, ncci->plcip, EV_PLCI_DISCONNECT_REQ);
672
673         cmd.command = ISDN_STAT_BHUP;
674         cmd.driver = card->myid;
675         cmd.arg = ncci->chan;
676         card->interface.statcallb(&cmd);
677         free_ncci(card, ncci);
678 }
679
680 /* ------------------------------------------------------------------ */
681
682 struct nccistatechange {
683         int actstate;
684         int nextstate;
685         int event;
686         void (*changefunc) (capidrv_contr * card, capidrv_ncci * ncci);
687 };
688
689 static struct nccistatechange nccitable[] =
690 {
691   /* N-0 */
692   {ST_NCCI_NONE, ST_NCCI_OUTGOING, EV_NCCI_CONNECT_B3_REQ, NULL},
693   {ST_NCCI_NONE, ST_NCCI_INCOMING, EV_NCCI_CONNECT_B3_IND, NULL},
694   /* N-0.1 */
695   {ST_NCCI_OUTGOING, ST_NCCI_ALLOCATED, EV_NCCI_CONNECT_B3_CONF_OK, NULL},
696   {ST_NCCI_OUTGOING, ST_NCCI_NONE, EV_NCCI_CONNECT_B3_CONF_ERROR, n0},
697   /* N-1 */
698   {ST_NCCI_INCOMING, ST_NCCI_DISCONNECTING, EV_NCCI_CONNECT_B3_REJECT, NULL},
699   {ST_NCCI_INCOMING, ST_NCCI_ALLOCATED, EV_NCCI_CONNECT_B3_RESP, NULL},
700   {ST_NCCI_INCOMING, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, NULL},
701   {ST_NCCI_INCOMING, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, NULL},
702   /* N-2 */
703   {ST_NCCI_ALLOCATED, ST_NCCI_ACTIVE, EV_NCCI_CONNECT_B3_ACTIVE_IND, NULL},
704   {ST_NCCI_ALLOCATED, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, NULL},
705   {ST_NCCI_ALLOCATED, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, NULL},
706   /* N-ACT */
707   {ST_NCCI_ACTIVE, ST_NCCI_ACTIVE, EV_NCCI_RESET_B3_IND, NULL},
708   {ST_NCCI_ACTIVE, ST_NCCI_RESETING, EV_NCCI_RESET_B3_REQ, NULL},
709   {ST_NCCI_ACTIVE, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, NULL},
710   {ST_NCCI_ACTIVE, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, NULL},
711   /* N-3 */
712   {ST_NCCI_RESETING, ST_NCCI_ACTIVE, EV_NCCI_RESET_B3_IND, NULL},
713   {ST_NCCI_RESETING, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, NULL},
714   {ST_NCCI_RESETING, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, NULL},
715   /* N-4 */
716   {ST_NCCI_DISCONNECTING, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, NULL},
717   {ST_NCCI_DISCONNECTING, ST_NCCI_PREVIOUS, EV_NCCI_DISCONNECT_B3_CONF_ERROR,NULL},
718   /* N-5 */
719   {ST_NCCI_DISCONNECTED, ST_NCCI_NONE, EV_NCCI_DISCONNECT_B3_RESP, n0},
720   {},
721 };
722
723 static void ncci_change_state(capidrv_contr * card, capidrv_ncci * ncci, int event)
724 {
725         struct nccistatechange *p = nccitable;
726         while (p->event) {
727                 if (ncci->state == p->actstate && p->event == event) {
728                         if (debugmode)
729                                 printk(KERN_DEBUG "capidrv-%d: ncci_change_state:0x%x %d -> %d\n",
730                                   card->contrnr, ncci->ncci, ncci->state, p->nextstate);
731                         if (p->nextstate == ST_NCCI_PREVIOUS) {
732                                 ncci->state = ncci->oldstate;
733                                 ncci->oldstate = p->actstate;
734                         } else {
735                                 ncci->oldstate = p->actstate;
736                                 ncci->state = p->nextstate;
737                         }
738                         if (p->changefunc)
739                                 p->changefunc(card, ncci);
740                         return;
741                 }
742                 p++;
743         }
744         printk(KERN_ERR "capidrv-%d: ncci_change_state:0x%x state=%d event=%d ????\n",
745                card->contrnr, ncci->ncci, ncci->state, event);
746 }
747
748 /* ------------------------------------------------------------------- */
749
750 static inline int new_bchan(capidrv_contr * card)
751 {
752         int i;
753         for (i = 0; i < card->nbchan; i++) {
754                 if (card->bchans[i].plcip == 0) {
755                         card->bchans[i].disconnecting = 0;
756                         return i;
757                 }
758         }
759         return -1;
760 }
761
762 /* ------------------------------------------------------------------- */
763
764 static void handle_controller(_cmsg * cmsg)
765 {
766         capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
767
768         if (!card) {
769                 printk(KERN_ERR "capidrv: %s from unknown controller 0x%x\n",
770                        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
771                        cmsg->adr.adrController & 0x7f);
772                 return;
773         }
774         switch (CAPICMD(cmsg->Command, cmsg->Subcommand)) {
775
776         case CAPI_LISTEN_CONF:  /* Controller */
777                 if (debugmode)
778                         printk(KERN_DEBUG "capidrv-%d: listenconf Info=0x%4x (%s) cipmask=0x%x\n",
779                                card->contrnr, cmsg->Info, capi_info2str(cmsg->Info), card->cipmask);
780                 if (cmsg->Info) {
781                         listen_change_state(card, EV_LISTEN_CONF_ERROR);
782                 } else if (card->cipmask == 0) {
783                         listen_change_state(card, EV_LISTEN_CONF_EMPTY);
784                 } else {
785                         listen_change_state(card, EV_LISTEN_CONF_OK);
786                 }
787                 break;
788
789         case CAPI_MANUFACTURER_IND:     /* Controller */
790                 if (   cmsg->ManuID == 0x214D5641
791                     && cmsg->Class == 0
792                     && cmsg->Function == 1) {
793                    u8  *data = cmsg->ManuData+3;
794                    u16  len = cmsg->ManuData[0];
795                    u16 layer;
796                    int direction;
797                    if (len == 255) {
798                       len = (cmsg->ManuData[1] | (cmsg->ManuData[2] << 8));
799                       data += 2;
800                    }
801                    len -= 2;
802                    layer = ((*(data-1)) << 8) | *(data-2);
803                    if (layer & 0x300)
804                         direction = (layer & 0x200) ? 0 : 1;
805                    else direction = (layer & 0x800) ? 0 : 1;
806                    if (layer & 0x0C00) {
807                         if ((layer & 0xff) == 0x80) {
808                            handle_dtrace_data(card, direction, 1, data, len);
809                            break;
810                         }
811                    } else if ((layer & 0xff) < 0x80) {
812                       handle_dtrace_data(card, direction, 0, data, len);
813                       break;
814                    }
815                    printk(KERN_INFO "capidrv-%d: %s from controller 0x%x layer 0x%x, ignored\n",
816                         card->contrnr, 
817                         capi_cmd2str(cmsg->Command, cmsg->Subcommand),
818                         cmsg->adr.adrController, layer);
819                    break;
820                 }
821                 goto ignored;
822         case CAPI_MANUFACTURER_CONF:    /* Controller */
823                 if (cmsg->ManuID == 0x214D5641) {
824                    char *s = NULL;
825                    switch (cmsg->Class) {
826                       case 0: break;
827                       case 1: s = "unknown class"; break;
828                       case 2: s = "unknown function"; break;
829                       default: s = "unkown error"; break;
830                    }
831                    if (s)
832                    printk(KERN_INFO "capidrv-%d: %s from controller 0x%x function %d: %s\n",
833                         card->contrnr,
834                         capi_cmd2str(cmsg->Command, cmsg->Subcommand),
835                         cmsg->adr.adrController,
836                         cmsg->Function, s);
837                    break;
838                 }
839                 goto ignored;
840         case CAPI_FACILITY_IND: /* Controller/plci/ncci */
841                 goto ignored;
842         case CAPI_FACILITY_CONF:        /* Controller/plci/ncci */
843                 goto ignored;
844         case CAPI_INFO_IND:     /* Controller/plci */
845                 goto ignored;
846         case CAPI_INFO_CONF:    /* Controller/plci */
847                 goto ignored;
848
849         default:
850                 printk(KERN_ERR "capidrv-%d: got %s from controller 0x%x ???",
851                        card->contrnr,
852                        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
853                        cmsg->adr.adrController);
854         }
855         return;
856
857       ignored:
858         printk(KERN_INFO "capidrv-%d: %s from controller 0x%x ignored\n",
859                card->contrnr,
860                capi_cmd2str(cmsg->Command, cmsg->Subcommand),
861                cmsg->adr.adrController);
862 }
863
864 static void handle_incoming_call(capidrv_contr * card, _cmsg * cmsg)
865 {
866         capidrv_plci *plcip;
867         capidrv_bchan *bchan;
868         isdn_ctrl cmd;
869         int chan;
870
871         if ((chan = new_bchan(card)) == -1) {
872                 printk(KERN_ERR "capidrv-%d: incoming call on not existing bchan ?\n", card->contrnr);
873                 return;
874         }
875         bchan = &card->bchans[chan];
876         if ((plcip = new_plci(card, chan)) == 0) {
877                 printk(KERN_ERR "capidrv-%d: incoming call: no memory, sorry.\n", card->contrnr);
878                 return;
879         }
880         bchan->incoming = 1;
881         plcip->plci = cmsg->adr.adrPLCI;
882         plci_change_state(card, plcip, EV_PLCI_CONNECT_IND);
883
884         cmd.command = ISDN_STAT_ICALL;
885         cmd.driver = card->myid;
886         cmd.arg = chan;
887         memset(&cmd.parm.setup, 0, sizeof(cmd.parm.setup));
888         strncpy(cmd.parm.setup.phone,
889                 cmsg->CallingPartyNumber + 3,
890                 cmsg->CallingPartyNumber[0] - 2);
891         strncpy(cmd.parm.setup.eazmsn,
892                 cmsg->CalledPartyNumber + 2,
893                 cmsg->CalledPartyNumber[0] - 1);
894         cmd.parm.setup.si1 = cip2si1(cmsg->CIPValue);
895         cmd.parm.setup.si2 = cip2si2(cmsg->CIPValue);
896         cmd.parm.setup.plan = cmsg->CallingPartyNumber[1];
897         cmd.parm.setup.screen = cmsg->CallingPartyNumber[2];
898
899         printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s\n", 
900                         card->contrnr,
901                         cmd.parm.setup.phone,
902                         cmd.parm.setup.si1,
903                         cmd.parm.setup.si2,
904                         cmd.parm.setup.eazmsn);
905
906         if (cmd.parm.setup.si1 == 1 && cmd.parm.setup.si2 != 0) {
907                 printk(KERN_INFO "capidrv-%d: patching si2=%d to 0 for VBOX\n", 
908                         card->contrnr,
909                         cmd.parm.setup.si2);
910                 cmd.parm.setup.si2 = 0;
911         }
912
913         switch (card->interface.statcallb(&cmd)) {
914         case 0:
915         case 3:
916                 /* No device matching this call.
917                  * and isdn_common.c has send a HANGUP command
918                  * which is ignored in state ST_PLCI_INCOMING,
919                  * so we send RESP to ignore the call
920                  */
921                 capi_cmsg_answer(cmsg);
922                 cmsg->Reject = 1;       /* ignore */
923                 send_message(card, cmsg);
924                 plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT);
925                 printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s ignored\n",
926                         card->contrnr,
927                         cmd.parm.setup.phone,
928                         cmd.parm.setup.si1,
929                         cmd.parm.setup.si2,
930                         cmd.parm.setup.eazmsn);
931                 break;
932         case 1:
933                 /* At least one device matching this call (RING on ttyI)
934                  * HL-driver may send ALERTING on the D-channel in this
935                  * case.
936                  * really means: RING on ttyI or a net interface
937                  * accepted this call already.
938                  *
939                  * If the call was accepted, state has already changed,
940                  * and CONNECT_RESP already sent.
941                  */
942                 if (plcip->state == ST_PLCI_INCOMING) {
943                         printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s tty alerting\n",
944                                 card->contrnr,
945                                 cmd.parm.setup.phone,
946                                 cmd.parm.setup.si1,
947                                 cmd.parm.setup.si2,
948                                 cmd.parm.setup.eazmsn);
949                         capi_fill_ALERT_REQ(cmsg,
950                                             global.ap.applid,
951                                             card->msgid++,
952                                             plcip->plci,        /* adr */
953                                             NULL,/* BChannelinformation */
954                                             NULL,/* Keypadfacility */
955                                             NULL,/* Useruserdata */
956                                             NULL /* Facilitydataarray */
957                         );
958                         plcip->msgid = cmsg->Messagenumber;
959                         send_message(card, cmsg);
960                 } else {
961                         printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s on netdev\n",
962                                 card->contrnr,
963                                 cmd.parm.setup.phone,
964                                 cmd.parm.setup.si1,
965                                 cmd.parm.setup.si2,
966                                 cmd.parm.setup.eazmsn);
967                 }
968                 break;
969
970         case 2:         /* Call will be rejected. */
971                 capi_cmsg_answer(cmsg);
972                 cmsg->Reject = 2;       /* reject call, normal call clearing */
973                 send_message(card, cmsg);
974                 plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT);
975                 break;
976
977         default:
978                 /* An error happened. (Invalid parameters for example.) */
979                 capi_cmsg_answer(cmsg);
980                 cmsg->Reject = 8;       /* reject call,
981                                            destination out of order */
982                 send_message(card, cmsg);
983                 plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT);
984                 break;
985         }
986         return;
987 }
988
989 static void handle_plci(_cmsg * cmsg)
990 {
991         capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
992         capidrv_plci *plcip;
993         isdn_ctrl cmd;
994
995         if (!card) {
996                 printk(KERN_ERR "capidrv: %s from unknown controller 0x%x\n",
997                        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
998                        cmsg->adr.adrController & 0x7f);
999                 return;
1000         }
1001         switch (CAPICMD(cmsg->Command, cmsg->Subcommand)) {
1002
1003         case CAPI_DISCONNECT_IND:       /* plci */
1004                 if (cmsg->Reason) {
1005                         printk(KERN_INFO "capidrv-%d: %s reason 0x%x (%s) for plci 0x%x\n",
1006                            card->contrnr,
1007                            capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1008                                cmsg->Reason, capi_info2str(cmsg->Reason), cmsg->adr.adrPLCI);
1009                 }
1010                 if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI))) {
1011                         capi_cmsg_answer(cmsg);
1012                         send_message(card, cmsg);
1013                         goto notfound;
1014                 }
1015                 card->bchans[plcip->chan].disconnecting = 1;
1016                 plci_change_state(card, plcip, EV_PLCI_DISCONNECT_IND);
1017                 capi_cmsg_answer(cmsg);
1018                 send_message(card, cmsg);
1019                 plci_change_state(card, plcip, EV_PLCI_DISCONNECT_RESP);
1020                 break;
1021
1022         case CAPI_DISCONNECT_CONF:      /* plci */
1023                 if (cmsg->Info) {
1024                         printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for plci 0x%x\n",
1025                            card->contrnr,
1026                            capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1027                                cmsg->Info, capi_info2str(cmsg->Info), 
1028                                cmsg->adr.adrPLCI);
1029                 }
1030                 if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI)))
1031                         goto notfound;
1032
1033                 card->bchans[plcip->chan].disconnecting = 1;
1034                 break;
1035
1036         case CAPI_ALERT_CONF:   /* plci */
1037                 if (cmsg->Info) {
1038                         printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for plci 0x%x\n",
1039                            card->contrnr,
1040                            capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1041                                cmsg->Info, capi_info2str(cmsg->Info), 
1042                                cmsg->adr.adrPLCI);
1043                 }
1044                 break;
1045
1046         case CAPI_CONNECT_IND:  /* plci */
1047                 handle_incoming_call(card, cmsg);
1048                 break;
1049
1050         case CAPI_CONNECT_CONF: /* plci */
1051                 if (cmsg->Info) {
1052                         printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for plci 0x%x\n",
1053                            card->contrnr,
1054                            capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1055                                cmsg->Info, capi_info2str(cmsg->Info), 
1056                                cmsg->adr.adrPLCI);
1057                 }
1058                 if (!(plcip = find_plci_by_msgid(card, cmsg->Messagenumber)))
1059                         goto notfound;
1060
1061                 plcip->plci = cmsg->adr.adrPLCI;
1062                 if (cmsg->Info) {
1063                         plci_change_state(card, plcip, EV_PLCI_CONNECT_CONF_ERROR);
1064                 } else {
1065                         plci_change_state(card, plcip, EV_PLCI_CONNECT_CONF_OK);
1066                 }
1067                 break;
1068
1069         case CAPI_CONNECT_ACTIVE_IND:   /* plci */
1070
1071                 if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI)))
1072                         goto notfound;
1073
1074                 if (card->bchans[plcip->chan].incoming) {
1075                         capi_cmsg_answer(cmsg);
1076                         send_message(card, cmsg);
1077                         plci_change_state(card, plcip, EV_PLCI_CONNECT_ACTIVE_IND);
1078                 } else {
1079                         capidrv_ncci *nccip;
1080                         capi_cmsg_answer(cmsg);
1081                         send_message(card, cmsg);
1082
1083                         nccip = new_ncci(card, plcip, cmsg->adr.adrPLCI);
1084
1085                         if (!nccip) {
1086                                 printk(KERN_ERR "capidrv-%d: no mem for ncci, sorry\n", card->contrnr);
1087                                 break;  /* $$$$ */
1088                         }
1089                         capi_fill_CONNECT_B3_REQ(cmsg,
1090                                                  global.ap.applid,
1091                                                  card->msgid++,
1092                                                  plcip->plci,   /* adr */
1093                                                  NULL   /* NCPI */
1094                         );
1095                         nccip->msgid = cmsg->Messagenumber;
1096                         send_message(card, cmsg);
1097                         cmd.command = ISDN_STAT_DCONN;
1098                         cmd.driver = card->myid;
1099                         cmd.arg = plcip->chan;
1100                         card->interface.statcallb(&cmd);
1101                         plci_change_state(card, plcip, EV_PLCI_CONNECT_ACTIVE_IND);
1102                         ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_REQ);
1103                 }
1104                 break;
1105
1106         case CAPI_INFO_IND:     /* Controller/plci */
1107
1108                 if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI)))
1109                         goto notfound;
1110
1111                 if (cmsg->InfoNumber == 0x4000) {
1112                         if (cmsg->InfoElement[0] == 4) {
1113                                 cmd.command = ISDN_STAT_CINF;
1114                                 cmd.driver = card->myid;
1115                                 cmd.arg = plcip->chan;
1116                                 sprintf(cmd.parm.num, "%lu",
1117                                         (unsigned long)
1118                                         ((u32) cmsg->InfoElement[1]
1119                                   | ((u32) (cmsg->InfoElement[2]) << 8)
1120                                  | ((u32) (cmsg->InfoElement[3]) << 16)
1121                                          | ((u32) (cmsg->InfoElement[4]) << 24)));
1122                                 card->interface.statcallb(&cmd);
1123                                 break;
1124                         }
1125                 }
1126                 printk(KERN_ERR "capidrv-%d: %s\n",
1127                                 card->contrnr, capi_cmsg2str(cmsg));
1128                 break;
1129
1130         case CAPI_CONNECT_ACTIVE_CONF:          /* plci */
1131                 goto ignored;
1132         case CAPI_SELECT_B_PROTOCOL_CONF:       /* plci */
1133                 goto ignored;
1134         case CAPI_FACILITY_IND: /* Controller/plci/ncci */
1135                 goto ignored;
1136         case CAPI_FACILITY_CONF:        /* Controller/plci/ncci */
1137                 goto ignored;
1138
1139         case CAPI_INFO_CONF:    /* Controller/plci */
1140                 goto ignored;
1141
1142         default:
1143                 printk(KERN_ERR "capidrv-%d: got %s for plci 0x%x ???",
1144                        card->contrnr,
1145                        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1146                        cmsg->adr.adrPLCI);
1147         }
1148         return;
1149       ignored:
1150         printk(KERN_INFO "capidrv-%d: %s for plci 0x%x ignored\n",
1151                card->contrnr,
1152                capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1153                cmsg->adr.adrPLCI);
1154         return;
1155       notfound:
1156         printk(KERN_ERR "capidrv-%d: %s: plci 0x%x not found\n",
1157                card->contrnr,
1158                capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1159                cmsg->adr.adrPLCI);
1160         return;
1161 }
1162
1163 static void handle_ncci(_cmsg * cmsg)
1164 {
1165         capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
1166         capidrv_plci *plcip;
1167         capidrv_ncci *nccip;
1168         isdn_ctrl cmd;
1169         int len;
1170
1171         if (!card) {
1172                 printk(KERN_ERR "capidrv: %s from unknown controller 0x%x\n",
1173                        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1174                        cmsg->adr.adrController & 0x7f);
1175                 return;
1176         }
1177         switch (CAPICMD(cmsg->Command, cmsg->Subcommand)) {
1178
1179         case CAPI_CONNECT_B3_ACTIVE_IND:        /* ncci */
1180                 if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
1181                         goto notfound;
1182
1183                 capi_cmsg_answer(cmsg);
1184                 send_message(card, cmsg);
1185                 ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_ACTIVE_IND);
1186
1187                 cmd.command = ISDN_STAT_BCONN;
1188                 cmd.driver = card->myid;
1189                 cmd.arg = nccip->chan;
1190                 card->interface.statcallb(&cmd);
1191
1192                 printk(KERN_INFO "capidrv-%d: chan %d up with ncci 0x%x\n",
1193                        card->contrnr, nccip->chan, nccip->ncci);
1194                 break;
1195
1196         case CAPI_CONNECT_B3_ACTIVE_CONF:       /* ncci */
1197                 goto ignored;
1198
1199         case CAPI_CONNECT_B3_IND:       /* ncci */
1200
1201                 plcip = find_plci_by_ncci(card, cmsg->adr.adrNCCI);
1202                 if (plcip) {
1203                         nccip = new_ncci(card, plcip, cmsg->adr.adrNCCI);
1204                         if (nccip) {
1205                                 ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_IND);
1206                                 capi_fill_CONNECT_B3_RESP(cmsg,
1207                                                           global.ap.applid,
1208                                                           card->msgid++,
1209                                                           nccip->ncci,  /* adr */
1210                                                           0,    /* Reject */
1211                                                           NULL  /* NCPI */
1212                                 );
1213                                 send_message(card, cmsg);
1214                                 ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_RESP);
1215                                 break;
1216                         }
1217                         printk(KERN_ERR "capidrv-%d: no mem for ncci, sorry\n",                                                 card->contrnr);
1218                 } else {
1219                         printk(KERN_ERR "capidrv-%d: %s: plci for ncci 0x%x not found\n",
1220                            card->contrnr,
1221                            capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1222                                cmsg->adr.adrNCCI);
1223                 }
1224                 capi_fill_CONNECT_B3_RESP(cmsg,
1225                                           global.ap.applid,
1226                                           card->msgid++,
1227                                           cmsg->adr.adrNCCI,
1228                                           2,    /* Reject */
1229                                           NULL  /* NCPI */
1230                 );
1231                 send_message(card, cmsg);
1232                 break;
1233
1234         case CAPI_CONNECT_B3_CONF:      /* ncci */
1235
1236                 if (!(nccip = find_ncci_by_msgid(card,
1237                                                  cmsg->adr.adrNCCI,
1238                                                  cmsg->Messagenumber)))
1239                         goto notfound;
1240
1241                 nccip->ncci = cmsg->adr.adrNCCI;
1242                 if (cmsg->Info) {
1243                         printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for ncci 0x%x\n",
1244                            card->contrnr,
1245                            capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1246                                cmsg->Info, capi_info2str(cmsg->Info), 
1247                                cmsg->adr.adrNCCI);
1248                 }
1249
1250                 if (cmsg->Info)
1251                         ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_CONF_ERROR);
1252                 else
1253                         ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_CONF_OK);
1254                 break;
1255
1256         case CAPI_CONNECT_B3_T90_ACTIVE_IND:    /* ncci */
1257                 capi_cmsg_answer(cmsg);
1258                 send_message(card, cmsg);
1259                 break;
1260
1261         case CAPI_DATA_B3_IND:  /* ncci */
1262                 /* handled in handle_data() */
1263                 goto ignored;
1264
1265         case CAPI_DATA_B3_CONF: /* ncci */
1266                 if (cmsg->Info) {
1267                         printk(KERN_WARNING "CAPI_DATA_B3_CONF: Info %x - %s\n",
1268                                 cmsg->Info, capi_info2str(cmsg->Info));
1269                 }
1270                 if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
1271                         goto notfound;
1272
1273                 len = capidrv_del_ack(nccip, cmsg->DataHandle);
1274                 if (len < 0)
1275                         break;
1276                 cmd.command = ISDN_STAT_BSENT;
1277                 cmd.driver = card->myid;
1278                 cmd.arg = nccip->chan;
1279                 cmd.parm.length = len;
1280                 card->interface.statcallb(&cmd);
1281                 break;
1282
1283         case CAPI_DISCONNECT_B3_IND:    /* ncci */
1284                 if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
1285                         goto notfound;
1286
1287                 card->bchans[nccip->chan].disconnecting = 1;
1288                 ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_IND);
1289                 capi_cmsg_answer(cmsg);
1290                 send_message(card, cmsg);
1291                 ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_RESP);
1292                 break;
1293
1294         case CAPI_DISCONNECT_B3_CONF:   /* ncci */
1295                 if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
1296                         goto notfound;
1297                 if (cmsg->Info) {
1298                         printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for ncci 0x%x\n",
1299                            card->contrnr,
1300                            capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1301                                cmsg->Info, capi_info2str(cmsg->Info), 
1302                                cmsg->adr.adrNCCI);
1303                         ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_CONF_ERROR);
1304                 }
1305                 break;
1306
1307         case CAPI_RESET_B3_IND: /* ncci */
1308                 if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
1309                         goto notfound;
1310                 ncci_change_state(card, nccip, EV_NCCI_RESET_B3_IND);
1311                 capi_cmsg_answer(cmsg);
1312                 send_message(card, cmsg);
1313                 break;
1314
1315         case CAPI_RESET_B3_CONF:        /* ncci */
1316                 goto ignored;   /* $$$$ */
1317
1318         case CAPI_FACILITY_IND: /* Controller/plci/ncci */
1319                 goto ignored;
1320         case CAPI_FACILITY_CONF:        /* Controller/plci/ncci */
1321                 goto ignored;
1322
1323         default:
1324                 printk(KERN_ERR "capidrv-%d: got %s for ncci 0x%x ???",
1325                        card->contrnr,
1326                        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1327                        cmsg->adr.adrNCCI);
1328         }
1329         return;
1330       ignored:
1331         printk(KERN_INFO "capidrv-%d: %s for ncci 0x%x ignored\n",
1332                card->contrnr,
1333                capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1334                cmsg->adr.adrNCCI);
1335         return;
1336       notfound:
1337         printk(KERN_ERR "capidrv-%d: %s: ncci 0x%x not found\n",
1338                card->contrnr,
1339                capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1340                cmsg->adr.adrNCCI);
1341 }
1342
1343
1344 static void handle_data(_cmsg * cmsg, struct sk_buff *skb)
1345 {
1346         capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
1347         capidrv_ncci *nccip;
1348
1349         if (!card) {
1350                 printk(KERN_ERR "capidrv: %s from unknown controller 0x%x\n",
1351                        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1352                        cmsg->adr.adrController & 0x7f);
1353                 kfree_skb(skb);
1354                 return;
1355         }
1356         if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI))) {
1357                 printk(KERN_ERR "capidrv-%d: %s: ncci 0x%x not found\n",
1358                        card->contrnr,
1359                        capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1360                        cmsg->adr.adrNCCI);
1361                 kfree_skb(skb);
1362                 return;
1363         }
1364         (void) skb_pull(skb, CAPIMSG_LEN(skb->data));
1365         card->interface.rcvcallb_skb(card->myid, nccip->chan, skb);
1366         capi_cmsg_answer(cmsg);
1367         send_message(card, cmsg);
1368 }
1369
1370 static _cmsg s_cmsg;
1371
1372 static void capidrv_recv_message(struct capi20_appl *ap, struct sk_buff *skb)
1373 {
1374         capi_message2cmsg(&s_cmsg, skb->data);
1375         if (debugmode > 3)
1376                 printk(KERN_DEBUG "capidrv_signal: applid=%d %s\n",
1377                        ap->applid, capi_cmsg2str(&s_cmsg));
1378         
1379         if (s_cmsg.Command == CAPI_DATA_B3
1380             && s_cmsg.Subcommand == CAPI_IND) {
1381                 handle_data(&s_cmsg, skb);
1382                 return;
1383         }
1384         if ((s_cmsg.adr.adrController & 0xffffff00) == 0)
1385                 handle_controller(&s_cmsg);
1386         else if ((s_cmsg.adr.adrPLCI & 0xffff0000) == 0)
1387                 handle_plci(&s_cmsg);
1388         else
1389                 handle_ncci(&s_cmsg);
1390         /*
1391          * data of skb used in s_cmsg,
1392          * free data when s_cmsg is not used again
1393          * thanks to Lars Heete <hel@admin.de>
1394          */
1395         kfree_skb(skb);
1396 }
1397
1398 /* ------------------------------------------------------------------- */
1399
1400 #define PUTBYTE_TO_STATUS(card, byte) \
1401         do { \
1402                 *(card)->q931_write++ = (byte); \
1403                 if ((card)->q931_write > (card)->q931_end) \
1404                         (card)->q931_write = (card)->q931_buf; \
1405         } while (0)
1406
1407 static void handle_dtrace_data(capidrv_contr *card,
1408                              int send, int level2, u8 *data, u16 len)
1409 {
1410         u8 *p, *end;
1411         isdn_ctrl cmd;
1412
1413         if (!len) {
1414                 printk(KERN_DEBUG "capidrv-%d: avmb1_q931_data: len == %d\n",
1415                                 card->contrnr, len);
1416                 return;
1417         }
1418
1419         if (level2) {
1420                 PUTBYTE_TO_STATUS(card, 'D');
1421                 PUTBYTE_TO_STATUS(card, '2');
1422                 PUTBYTE_TO_STATUS(card, send ? '>' : '<');
1423                 PUTBYTE_TO_STATUS(card, ':');
1424         } else {
1425                 PUTBYTE_TO_STATUS(card, 'D');
1426                 PUTBYTE_TO_STATUS(card, '3');
1427                 PUTBYTE_TO_STATUS(card, send ? '>' : '<');
1428                 PUTBYTE_TO_STATUS(card, ':');
1429         }
1430
1431         for (p = data, end = data+len; p < end; p++) {
1432                 u8 w;
1433                 PUTBYTE_TO_STATUS(card, ' ');
1434                 w = (*p >> 4) & 0xf;
1435                 PUTBYTE_TO_STATUS(card, (w < 10) ? '0'+w : 'A'-10+w);
1436                 w = *p & 0xf;
1437                 PUTBYTE_TO_STATUS(card, (w < 10) ? '0'+w : 'A'-10+w);
1438         }
1439         PUTBYTE_TO_STATUS(card, '\n');
1440
1441         cmd.command = ISDN_STAT_STAVAIL;
1442         cmd.driver = card->myid;
1443         cmd.arg = len*3+5;
1444         card->interface.statcallb(&cmd);
1445 }
1446
1447 /* ------------------------------------------------------------------- */
1448
1449 static _cmsg cmdcmsg;
1450
1451 static int capidrv_ioctl(isdn_ctrl * c, capidrv_contr * card)
1452 {
1453         switch (c->arg) {
1454         case 1:
1455                 debugmode = (int)(*((unsigned int *)c->parm.num));
1456                 printk(KERN_DEBUG "capidrv-%d: debugmode=%d\n",
1457                                 card->contrnr, debugmode);
1458                 return 0;
1459         default:
1460                 printk(KERN_DEBUG "capidrv-%d: capidrv_ioctl(%ld) called ??\n",
1461                                 card->contrnr, c->arg);
1462                 return -EINVAL;
1463         }
1464         return -EINVAL;
1465 }
1466
1467 /*
1468  * Handle leased lines (CAPI-Bundling)
1469  */
1470
1471 struct internal_bchannelinfo {
1472    unsigned short channelalloc;
1473    unsigned short operation;
1474    unsigned char  cmask[31];
1475 };
1476
1477 static int decodeFVteln(char *teln, unsigned long *bmaskp, int *activep)
1478 {
1479         unsigned long bmask = 0;
1480         int active = !0;
1481         char *s;
1482         int i;
1483
1484         if (strncmp(teln, "FV:", 3) != 0)
1485                 return 1;
1486         s = teln + 3;
1487         while (*s && *s == ' ') s++;
1488         if (!*s) return -2;
1489         if (*s == 'p' || *s == 'P') {
1490                 active = 0;
1491                 s++;
1492         }
1493         if (*s == 'a' || *s == 'A') {
1494                 active = !0;
1495                 s++;
1496         }
1497         while (*s) {
1498                 int digit1 = 0;
1499                 int digit2 = 0;
1500                 if (!isdigit(*s)) return -3;
1501                 while (isdigit(*s)) { digit1 = digit1*10 + (*s - '0'); s++; }
1502                 if (digit1 <= 0 && digit1 > 30) return -4;
1503                 if (*s == 0 || *s == ',' || *s == ' ') {
1504                         bmask |= (1 << digit1);
1505                         digit1 = 0;
1506                         if (*s) s++;
1507                         continue;
1508                 }
1509                 if (*s != '-') return -5;
1510                 s++;
1511                 if (!isdigit(*s)) return -3;
1512                 while (isdigit(*s)) { digit2 = digit2*10 + (*s - '0'); s++; }
1513                 if (digit2 <= 0 && digit2 > 30) return -4;
1514                 if (*s == 0 || *s == ',' || *s == ' ') {
1515                         if (digit1 > digit2)
1516                                 for (i = digit2; i <= digit1 ; i++)
1517                                         bmask |= (1 << i);
1518                         else 
1519                                 for (i = digit1; i <= digit2 ; i++)
1520                                         bmask |= (1 << i);
1521                         digit1 = digit2 = 0;
1522                         if (*s) s++;
1523                         continue;
1524                 }
1525                 return -6;
1526         }
1527         if (activep) *activep = active;
1528         if (bmaskp) *bmaskp = bmask;
1529         return 0;
1530 }
1531
1532 static int FVteln2capi20(char *teln, u8 AdditionalInfo[1+2+2+31])
1533 {
1534         unsigned long bmask;
1535         int active;
1536         int rc, i;
1537    
1538         rc = decodeFVteln(teln, &bmask, &active);
1539         if (rc) return rc;
1540         /* Length */
1541         AdditionalInfo[0] = 2+2+31;
1542         /* Channel: 3 => use channel allocation */
1543         AdditionalInfo[1] = 3; AdditionalInfo[2] = 0;
1544         /* Operation: 0 => DTE mode, 1 => DCE mode */
1545         if (active) {
1546                 AdditionalInfo[3] = 0; AdditionalInfo[4] = 0;
1547         } else {
1548                 AdditionalInfo[3] = 1; AdditionalInfo[4] = 0;
1549         }
1550         /* Channel mask array */
1551         AdditionalInfo[5] = 0; /* no D-Channel */
1552         for (i=1; i <= 30; i++)
1553                 AdditionalInfo[5+i] = (bmask & (1 << i)) ? 0xff : 0;
1554         return 0;
1555 }
1556
1557 static int capidrv_command(isdn_ctrl * c, capidrv_contr * card)
1558 {
1559         isdn_ctrl cmd;
1560         struct capidrv_bchan *bchan;
1561         struct capidrv_plci *plcip;
1562         u8 AdditionalInfo[1+2+2+31];
1563         int rc, isleasedline = 0;
1564
1565         if (c->command == ISDN_CMD_IOCTL)
1566                 return capidrv_ioctl(c, card);
1567
1568         switch (c->command) {
1569         case ISDN_CMD_DIAL:{
1570                         u8 calling[ISDN_MSNLEN + 3];
1571                         u8 called[ISDN_MSNLEN + 2];
1572
1573                         if (debugmode)
1574                                 printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_DIAL(ch=%ld,\"%s,%d,%d,%s\")\n",
1575                                         card->contrnr,
1576                                         c->arg,
1577                                         c->parm.setup.phone,
1578                                         c->parm.setup.si1,
1579                                         c->parm.setup.si2,
1580                                         c->parm.setup.eazmsn);
1581
1582                         bchan = &card->bchans[c->arg % card->nbchan];
1583
1584                         if (bchan->plcip) {
1585                                 printk(KERN_ERR "capidrv-%d: dail ch=%ld,\"%s,%d,%d,%s\" in use (plci=0x%x)\n",
1586                                         card->contrnr,
1587                                         c->arg, 
1588                                         c->parm.setup.phone,
1589                                         c->parm.setup.si1,
1590                                         c->parm.setup.si2,
1591                                         c->parm.setup.eazmsn,
1592                                         bchan->plcip->plci);
1593                                 return 0;
1594                         }
1595                         bchan->si1 = c->parm.setup.si1;
1596                         bchan->si2 = c->parm.setup.si2;
1597
1598                         strncpy(bchan->num, c->parm.setup.phone, sizeof(bchan->num));
1599                         strncpy(bchan->mynum, c->parm.setup.eazmsn, sizeof(bchan->mynum));
1600                         rc = FVteln2capi20(bchan->num, AdditionalInfo);
1601                         isleasedline = (rc == 0);
1602                         if (rc < 0)
1603                                 printk(KERN_ERR "capidrv-%d: WARNING: invalid leased linedefinition \"%s\"\n", card->contrnr, bchan->num);
1604
1605                         if (isleasedline) {
1606                                 calling[0] = 0;
1607                                 called[0] = 0;
1608                                 if (debugmode)
1609                                         printk(KERN_DEBUG "capidrv-%d: connecting leased line\n", card->contrnr);
1610                         } else {
1611                                 calling[0] = strlen(bchan->mynum) + 2;
1612                                 calling[1] = 0;
1613                                 calling[2] = 0x80;
1614                                 strncpy(calling + 3, bchan->mynum, ISDN_MSNLEN);
1615                                 called[0] = strlen(bchan->num) + 1;
1616                                 called[1] = 0x80;
1617                                 strncpy(called + 2, bchan->num, ISDN_MSNLEN);
1618                         }
1619
1620                         capi_fill_CONNECT_REQ(&cmdcmsg,
1621                                               global.ap.applid,
1622                                               card->msgid++,
1623                                               card->contrnr,    /* adr */
1624                                           si2cip(bchan->si1, bchan->si2),       /* cipvalue */
1625                                               called,   /* CalledPartyNumber */
1626                                               calling,  /* CallingPartyNumber */
1627                                               NULL,     /* CalledPartySubaddress */
1628                                               NULL,     /* CallingPartySubaddress */
1629                                             b1prot(bchan->l2, bchan->l3),       /* B1protocol */
1630                                             b2prot(bchan->l2, bchan->l3),       /* B2protocol */
1631                                             b3prot(bchan->l2, bchan->l3),       /* B3protocol */
1632                                             b1config(bchan->l2, bchan->l3),     /* B1configuration */
1633                                               NULL,     /* B2configuration */
1634                                               NULL,     /* B3configuration */
1635                                               NULL,     /* BC */
1636                                               NULL,     /* LLC */
1637                                               NULL,     /* HLC */
1638                                               /* BChannelinformation */
1639                                               isleasedline ? AdditionalInfo : NULL,
1640                                               NULL,     /* Keypadfacility */
1641                                               NULL,     /* Useruserdata */
1642                                               NULL      /* Facilitydataarray */
1643                             );
1644                         if ((plcip = new_plci(card, (c->arg % card->nbchan))) == 0) {
1645                                 cmd.command = ISDN_STAT_DHUP;
1646                                 cmd.driver = card->myid;
1647                                 cmd.arg = (c->arg % card->nbchan);
1648                                 card->interface.statcallb(&cmd);
1649                                 return -1;
1650                         }
1651                         plcip->msgid = cmdcmsg.Messagenumber;
1652                         plcip->leasedline = isleasedline;
1653                         plci_change_state(card, plcip, EV_PLCI_CONNECT_REQ);
1654                         send_message(card, &cmdcmsg);
1655                         return 0;
1656                 }
1657
1658         case ISDN_CMD_ACCEPTD:
1659
1660                 bchan = &card->bchans[c->arg % card->nbchan];
1661                 if (debugmode)
1662                         printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_ACCEPTD(ch=%ld) l2=%d l3=%d\n",
1663                                card->contrnr,
1664                                c->arg, bchan->l2, bchan->l3);
1665
1666                 capi_fill_CONNECT_RESP(&cmdcmsg,
1667                                        global.ap.applid,
1668                                        card->msgid++,
1669                                        bchan->plcip->plci,      /* adr */
1670                                        0,       /* Reject */
1671                                        b1prot(bchan->l2, bchan->l3),    /* B1protocol */
1672                                        b2prot(bchan->l2, bchan->l3),    /* B2protocol */
1673                                        b3prot(bchan->l2, bchan->l3),    /* B3protocol */
1674                                        b1config(bchan->l2, bchan->l3),  /* B1configuration */
1675                                        NULL,    /* B2configuration */
1676                                        NULL,    /* B3configuration */
1677                                        NULL,    /* ConnectedNumber */
1678                                        NULL,    /* ConnectedSubaddress */
1679                                        NULL,    /* LLC */
1680                                        NULL,    /* BChannelinformation */
1681                                        NULL,    /* Keypadfacility */
1682                                        NULL,    /* Useruserdata */
1683                                        NULL     /* Facilitydataarray */
1684                 );
1685                 capi_cmsg2message(&cmdcmsg, cmdcmsg.buf);
1686                 plci_change_state(card, bchan->plcip, EV_PLCI_CONNECT_RESP);
1687                 send_message(card, &cmdcmsg);
1688                 return 0;
1689
1690         case ISDN_CMD_ACCEPTB:
1691                 if (debugmode)
1692                         printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_ACCEPTB(ch=%ld)\n",
1693                                card->contrnr,
1694                                c->arg);
1695                 return -ENOSYS;
1696
1697         case ISDN_CMD_HANGUP:
1698                 if (debugmode)
1699                         printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_HANGUP(ch=%ld)\n",
1700                                card->contrnr,
1701                                c->arg);
1702                 bchan = &card->bchans[c->arg % card->nbchan];
1703
1704                 if (bchan->disconnecting) {
1705                         if (debugmode)
1706                                 printk(KERN_DEBUG "capidrv-%d: chan %ld already disconnecting ...\n",
1707                                        card->contrnr,
1708                                        c->arg);
1709                         return 0;
1710                 }
1711                 if (bchan->nccip) {
1712                         bchan->disconnecting = 1;
1713                         capi_fill_DISCONNECT_B3_REQ(&cmdcmsg,
1714                                                     global.ap.applid,
1715                                                     card->msgid++,
1716                                                     bchan->nccip->ncci,
1717                                                     NULL        /* NCPI */
1718                         );
1719                         ncci_change_state(card, bchan->nccip, EV_NCCI_DISCONNECT_B3_REQ);
1720                         send_message(card, &cmdcmsg);
1721                         return 0;
1722                 } else if (bchan->plcip) {
1723                         if (bchan->plcip->state == ST_PLCI_INCOMING) {
1724                                 /*
1725                                  * just ignore, we a called from
1726                                  * isdn_status_callback(),
1727                                  * which will return 0 or 2, this is handled
1728                                  * by the CONNECT_IND handler
1729                                  */
1730                                 bchan->disconnecting = 1;
1731                                 return 0;
1732                         } else if (bchan->plcip->plci) {
1733                                 bchan->disconnecting = 1;
1734                                 capi_fill_DISCONNECT_REQ(&cmdcmsg,
1735                                                          global.ap.applid,
1736                                                          card->msgid++,
1737                                                       bchan->plcip->plci,
1738                                                          NULL,  /* BChannelinformation */
1739                                                          NULL,  /* Keypadfacility */
1740                                                          NULL,  /* Useruserdata */
1741                                                          NULL   /* Facilitydataarray */
1742                                 );
1743                                 plci_change_state(card, bchan->plcip, EV_PLCI_DISCONNECT_REQ);
1744                                 send_message(card, &cmdcmsg);
1745                                 return 0;
1746                         } else {
1747                                 printk(KERN_ERR "capidrv-%d: chan %ld disconnect request while waiting for CONNECT_CONF\n",
1748                                        card->contrnr,
1749                                        c->arg);
1750                                 return -EINVAL;
1751                         }
1752                 }
1753                 printk(KERN_ERR "capidrv-%d: chan %ld disconnect request on free channel\n",
1754                                        card->contrnr,
1755                                        c->arg);
1756                 return -EINVAL;
1757 /* ready */
1758
1759         case ISDN_CMD_SETL2:
1760                 if (debugmode)
1761                         printk(KERN_DEBUG "capidrv-%d: set L2 on chan %ld to %ld\n",
1762                                card->contrnr,
1763                                (c->arg & 0xff), (c->arg >> 8));
1764                 bchan = &card->bchans[(c->arg & 0xff) % card->nbchan];
1765                 bchan->l2 = (c->arg >> 8);
1766                 return 0;
1767
1768         case ISDN_CMD_SETL3:
1769                 if (debugmode)
1770                         printk(KERN_DEBUG "capidrv-%d: set L3 on chan %ld to %ld\n",
1771                                card->contrnr,
1772                                (c->arg & 0xff), (c->arg >> 8));
1773                 bchan = &card->bchans[(c->arg & 0xff) % card->nbchan];
1774                 bchan->l3 = (c->arg >> 8);
1775                 return 0;
1776
1777         case ISDN_CMD_SETEAZ:
1778                 if (debugmode)
1779                         printk(KERN_DEBUG "capidrv-%d: set EAZ \"%s\" on chan %ld\n",
1780                                card->contrnr,
1781                                c->parm.num, c->arg);
1782                 bchan = &card->bchans[c->arg % card->nbchan];
1783                 strncpy(bchan->msn, c->parm.num, ISDN_MSNLEN);
1784                 return 0;
1785
1786         case ISDN_CMD_CLREAZ:
1787                 if (debugmode)
1788                         printk(KERN_DEBUG "capidrv-%d: clearing EAZ on chan %ld\n",
1789                                         card->contrnr, c->arg);
1790                 bchan = &card->bchans[c->arg % card->nbchan];
1791                 bchan->msn[0] = 0;
1792                 return 0;
1793
1794         default:
1795                 printk(KERN_ERR "capidrv-%d: ISDN_CMD_%d, Huh?\n",
1796                                         card->contrnr, c->command);
1797                 return -EINVAL;
1798         }
1799         return 0;
1800 }
1801
1802 static int if_command(isdn_ctrl * c)
1803 {
1804         capidrv_contr *card = findcontrbydriverid(c->driver);
1805
1806         if (card)
1807                 return capidrv_command(c, card);
1808
1809         printk(KERN_ERR
1810              "capidrv: if_command %d called with invalid driverId %d!\n",
1811                                                 c->command, c->driver);
1812         return -ENODEV;
1813 }
1814
1815 static _cmsg sendcmsg;
1816
1817 static int if_sendbuf(int id, int channel, int doack, struct sk_buff *skb)
1818 {
1819         capidrv_contr *card = findcontrbydriverid(id);
1820         capidrv_bchan *bchan;
1821         capidrv_ncci *nccip;
1822         int len = skb->len;
1823         int msglen;
1824         u16 errcode;
1825         u16 datahandle;
1826
1827         if (!card) {
1828                 printk(KERN_ERR "capidrv: if_sendbuf called with invalid driverId %d!\n",
1829                        id);
1830                 return 0;
1831         }
1832         if (debugmode > 4)
1833                 printk(KERN_DEBUG "capidrv-%d: sendbuf len=%d skb=%p doack=%d\n",
1834                                         card->contrnr, len, skb, doack);
1835         bchan = &card->bchans[channel % card->nbchan];
1836         nccip = bchan->nccip;
1837         if (!nccip || nccip->state != ST_NCCI_ACTIVE) {
1838                 printk(KERN_ERR "capidrv-%d: if_sendbuf: %s:%d: chan not up!\n",
1839                        card->contrnr, card->name, channel);
1840                 return 0;
1841         }
1842         datahandle = nccip->datahandle;
1843         capi_fill_DATA_B3_REQ(&sendcmsg, global.ap.applid, card->msgid++,
1844                               nccip->ncci,      /* adr */
1845                               (u32) skb->data,  /* Data */
1846                               skb->len,         /* DataLength */
1847                               datahandle,       /* DataHandle */
1848                               0 /* Flags */
1849             );
1850
1851         if (capidrv_add_ack(nccip, datahandle, doack ? (int)skb->len : -1) < 0)
1852            return 0;
1853
1854         capi_cmsg2message(&sendcmsg, sendcmsg.buf);
1855         msglen = CAPIMSG_LEN(sendcmsg.buf);
1856         if (skb_headroom(skb) < msglen) {
1857                 struct sk_buff *nskb = skb_realloc_headroom(skb, msglen);
1858                 if (!nskb) {
1859                         printk(KERN_ERR "capidrv-%d: if_sendbuf: no memory\n",
1860                                 card->contrnr);
1861                         (void)capidrv_del_ack(nccip, datahandle);
1862                         return 0;
1863                 }
1864                 printk(KERN_DEBUG "capidrv-%d: only %d bytes headroom, need %d\n",
1865                        card->contrnr, skb_headroom(skb), msglen);
1866                 memcpy(skb_push(nskb, msglen), sendcmsg.buf, msglen);
1867                 errcode = capi20_put_message(&global.ap, nskb);
1868                 if (errcode == CAPI_NOERROR) {
1869                         dev_kfree_skb(skb);
1870                         nccip->datahandle++;
1871                         return len;
1872                 }
1873                 if (debugmode > 3)
1874                         printk(KERN_DEBUG "capidrv-%d: sendbuf putmsg ret(%x) - %s\n",
1875                                 card->contrnr, errcode, capi_info2str(errcode));
1876                 (void)capidrv_del_ack(nccip, datahandle);
1877                 dev_kfree_skb(nskb);
1878                 return errcode == CAPI_SENDQUEUEFULL ? 0 : -1;
1879         } else {
1880                 memcpy(skb_push(skb, msglen), sendcmsg.buf, msglen);
1881                 errcode = capi20_put_message(&global.ap, skb);
1882                 if (errcode == CAPI_NOERROR) {
1883                         nccip->datahandle++;
1884                         return len;
1885                 }
1886                 if (debugmode > 3)
1887                         printk(KERN_DEBUG "capidrv-%d: sendbuf putmsg ret(%x) - %s\n",
1888                                 card->contrnr, errcode, capi_info2str(errcode));
1889                 skb_pull(skb, msglen);
1890                 (void)capidrv_del_ack(nccip, datahandle);
1891                 return errcode == CAPI_SENDQUEUEFULL ? 0 : -1;
1892         }
1893 }
1894
1895 static int if_readstat(u8 __user *buf, int len, int id, int channel)
1896 {
1897         capidrv_contr *card = findcontrbydriverid(id);
1898         int count;
1899         u8 __user *p;
1900
1901         if (!card) {
1902                 printk(KERN_ERR "capidrv: if_readstat called with invalid driverId %d!\n",
1903                        id);
1904                 return -ENODEV;
1905         }
1906
1907         for (p=buf, count=0; count < len; p++, count++) {
1908                 if (put_user(*card->q931_read++, p))
1909                         return -EFAULT;
1910                 if (card->q931_read > card->q931_end)
1911                         card->q931_read = card->q931_buf;
1912         }
1913         return count;
1914
1915 }
1916
1917 static void enable_dchannel_trace(capidrv_contr *card)
1918 {
1919         u8 manufacturer[CAPI_MANUFACTURER_LEN];
1920         capi_version version;
1921         u16 contr = card->contrnr;
1922         u16 errcode;
1923         u16 avmversion[3];
1924
1925         errcode = capi20_get_manufacturer(contr, manufacturer);
1926         if (errcode != CAPI_NOERROR) {
1927            printk(KERN_ERR "%s: can't get manufacturer (0x%x)\n",
1928                         card->name, errcode);
1929            return;
1930         }
1931         if (strstr(manufacturer, "AVM") == 0) {
1932            printk(KERN_ERR "%s: not from AVM, no d-channel trace possible (%s)\n",
1933                         card->name, manufacturer);
1934            return;
1935         }
1936         errcode = capi20_get_version(contr, &version);
1937         if (errcode != CAPI_NOERROR) {
1938            printk(KERN_ERR "%s: can't get version (0x%x)\n",
1939                         card->name, errcode);
1940            return;
1941         }
1942         avmversion[0] = (version.majormanuversion >> 4) & 0x0f;
1943         avmversion[1] = (version.majormanuversion << 4) & 0xf0;
1944         avmversion[1] |= (version.minormanuversion >> 4) & 0x0f;
1945         avmversion[2] |= version.minormanuversion & 0x0f;
1946
1947         if (avmversion[0] > 3 || (avmversion[0] == 3 && avmversion[1] > 5)) {
1948                 printk(KERN_INFO "%s: D2 trace enabled\n", card->name);
1949                 capi_fill_MANUFACTURER_REQ(&cmdcmsg, global.ap.applid,
1950                                            card->msgid++,
1951                                            contr,
1952                                            0x214D5641,  /* ManuID */
1953                                            0,           /* Class */
1954                                            1,           /* Function */
1955                                            (_cstruct)"\004\200\014\000\000");
1956         } else {
1957                 printk(KERN_INFO "%s: D3 trace enabled\n", card->name);
1958                 capi_fill_MANUFACTURER_REQ(&cmdcmsg, global.ap.applid,
1959                                            card->msgid++,
1960                                            contr,
1961                                            0x214D5641,  /* ManuID */
1962                                            0,           /* Class */
1963                                            1,           /* Function */
1964                                            (_cstruct)"\004\002\003\000\000");
1965         }
1966         send_message(card, &cmdcmsg);
1967 }
1968
1969
1970 static void send_listen(capidrv_contr *card)
1971 {
1972         capi_fill_LISTEN_REQ(&cmdcmsg, global.ap.applid,
1973                              card->msgid++,
1974                              card->contrnr, /* controller */
1975                              1 << 6,    /* Infomask */
1976                              card->cipmask,
1977                              card->cipmask2,
1978                              NULL, NULL);
1979         send_message(card, &cmdcmsg);
1980         listen_change_state(card, EV_LISTEN_REQ);
1981 }
1982
1983 static void listentimerfunc(unsigned long x)
1984 {
1985         capidrv_contr *card = (capidrv_contr *)x;
1986         if (card->state != ST_LISTEN_NONE && card->state != ST_LISTEN_ACTIVE)
1987                 printk(KERN_ERR "%s: controller dead ??\n", card->name);
1988         send_listen(card);
1989         mod_timer(&card->listentimer, jiffies + 60*HZ);
1990 }
1991
1992
1993 static int capidrv_addcontr(u16 contr, struct capi_profile *profp)
1994 {
1995         capidrv_contr *card;
1996         unsigned long flags;
1997         isdn_ctrl cmd;
1998         char id[20];
1999         int i;
2000
2001         sprintf(id, "capidrv-%d", contr);
2002         if (!try_module_get(THIS_MODULE)) {
2003                 printk(KERN_WARNING "capidrv: (%s) Could not reserve module\n", id);
2004                 return -1;
2005         }
2006         if (!(card = kzalloc(sizeof(capidrv_contr), GFP_ATOMIC))) {
2007                 printk(KERN_WARNING
2008                  "capidrv: (%s) Could not allocate contr-struct.\n", id);
2009                 return -1;
2010         }
2011         card->owner = THIS_MODULE;
2012         init_timer(&card->listentimer);
2013         strcpy(card->name, id);
2014         card->contrnr = contr;
2015         card->nbchan = profp->nbchannel;
2016         card->bchans = (capidrv_bchan *) kmalloc(sizeof(capidrv_bchan) * card->nbchan, GFP_ATOMIC);
2017         if (!card->bchans) {
2018                 printk(KERN_WARNING
2019                 "capidrv: (%s) Could not allocate bchan-structs.\n", id);
2020                 module_put(card->owner);
2021                 kfree(card);
2022                 return -1;
2023         }
2024         card->interface.channels = profp->nbchannel;
2025         card->interface.maxbufsize = 2048;
2026         card->interface.command = if_command;
2027         card->interface.writebuf_skb = if_sendbuf;
2028         card->interface.writecmd = NULL;
2029         card->interface.readstat = if_readstat;
2030         card->interface.features = ISDN_FEATURE_L2_HDLC |
2031                                    ISDN_FEATURE_L2_TRANS |
2032                                    ISDN_FEATURE_L3_TRANS |
2033                                    ISDN_FEATURE_P_UNKNOWN |
2034                                    ISDN_FEATURE_L2_X75I |
2035                                    ISDN_FEATURE_L2_X75UI |
2036                                    ISDN_FEATURE_L2_X75BUI;
2037         if (profp->support1 & (1<<2))
2038                 card->interface.features |= ISDN_FEATURE_L2_V11096 |
2039                                             ISDN_FEATURE_L2_V11019 |
2040                                             ISDN_FEATURE_L2_V11038;
2041         if (profp->support1 & (1<<8))
2042                 card->interface.features |= ISDN_FEATURE_L2_MODEM;
2043         card->interface.hl_hdrlen = 22; /* len of DATA_B3_REQ */
2044         strncpy(card->interface.id, id, sizeof(card->interface.id) - 1);
2045
2046
2047         card->q931_read = card->q931_buf;
2048         card->q931_write = card->q931_buf;
2049         card->q931_end = card->q931_buf + sizeof(card->q931_buf) - 1;
2050
2051         if (!register_isdn(&card->interface)) {
2052                 printk(KERN_ERR "capidrv: Unable to register contr %s\n", id);
2053                 kfree(card->bchans);
2054                 module_put(card->owner);
2055                 kfree(card);
2056                 return -1;
2057         }
2058         card->myid = card->interface.channels;
2059         memset(card->bchans, 0, sizeof(capidrv_bchan) * card->nbchan);
2060         for (i = 0; i < card->nbchan; i++) {
2061                 card->bchans[i].contr = card;
2062         }
2063
2064         spin_lock_irqsave(&global_lock, flags);
2065         card->next = global.contr_list;
2066         global.contr_list = card;
2067         global.ncontr++;
2068         spin_unlock_irqrestore(&global_lock, flags);
2069
2070         cmd.command = ISDN_STAT_RUN;
2071         cmd.driver = card->myid;
2072         card->interface.statcallb(&cmd);
2073
2074         card->cipmask = 0x1FFF03FF;     /* any */
2075         card->cipmask2 = 0;
2076
2077         card->listentimer.data = (unsigned long)card;
2078         card->listentimer.function = listentimerfunc;
2079         send_listen(card);
2080         mod_timer(&card->listentimer, jiffies + 60*HZ);
2081
2082         printk(KERN_INFO "%s: now up (%d B channels)\n",
2083                 card->name, card->nbchan);
2084
2085         enable_dchannel_trace(card);
2086
2087         return 0;
2088 }
2089
2090 static int capidrv_delcontr(u16 contr)
2091 {
2092         capidrv_contr **pp, *card;
2093         unsigned long flags;
2094         isdn_ctrl cmd;
2095
2096         spin_lock_irqsave(&global_lock, flags);
2097         for (card = global.contr_list; card; card = card->next) {
2098                 if (card->contrnr == contr)
2099                         break;
2100         }
2101         if (!card) {
2102                 spin_unlock_irqrestore(&global_lock, flags);
2103                 printk(KERN_ERR "capidrv: delcontr: no contr %u\n", contr);
2104                 return -1;
2105         }
2106         #warning FIXME: maybe a race condition the card should be removed here from global list /kkeil
2107         spin_unlock_irqrestore(&global_lock, flags);
2108
2109         del_timer(&card->listentimer);
2110
2111         if (debugmode)
2112                 printk(KERN_DEBUG "capidrv-%d: id=%d unloading\n",
2113                                         card->contrnr, card->myid);
2114
2115         cmd.command = ISDN_STAT_STOP;
2116         cmd.driver = card->myid;
2117         card->interface.statcallb(&cmd);
2118
2119         while (card->nbchan) {
2120
2121                 cmd.command = ISDN_STAT_DISCH;
2122                 cmd.driver = card->myid;
2123                 cmd.arg = card->nbchan-1;
2124                 cmd.parm.num[0] = 0;
2125                 if (debugmode)
2126                         printk(KERN_DEBUG "capidrv-%d: id=%d disable chan=%ld\n",
2127                                         card->contrnr, card->myid, cmd.arg);
2128                 card->interface.statcallb(&cmd);
2129
2130                 if (card->bchans[card->nbchan-1].nccip)
2131                         free_ncci(card, card->bchans[card->nbchan-1].nccip);
2132                 if (card->bchans[card->nbchan-1].plcip)
2133                         free_plci(card, card->bchans[card->nbchan-1].plcip);
2134                 if (card->plci_list)
2135                         printk(KERN_ERR "capidrv: bug in free_plci()\n");
2136                 card->nbchan--;
2137         }
2138         kfree(card->bchans);
2139         card->bchans = NULL;
2140
2141         if (debugmode)
2142                 printk(KERN_DEBUG "capidrv-%d: id=%d isdn unload\n",
2143                                         card->contrnr, card->myid);
2144
2145         cmd.command = ISDN_STAT_UNLOAD;
2146         cmd.driver = card->myid;
2147         card->interface.statcallb(&cmd);
2148
2149         if (debugmode)
2150                 printk(KERN_DEBUG "capidrv-%d: id=%d remove contr from list\n",
2151                                         card->contrnr, card->myid);
2152
2153         spin_lock_irqsave(&global_lock, flags);
2154         for (pp = &global.contr_list; *pp; pp = &(*pp)->next) {
2155                 if (*pp == card) {
2156                         *pp = (*pp)->next;
2157                         card->next = NULL;
2158                         global.ncontr--;
2159                         break;
2160                 }
2161         }
2162         spin_unlock_irqrestore(&global_lock, flags);
2163
2164         module_put(card->owner);
2165         printk(KERN_INFO "%s: now down.\n", card->name);
2166         kfree(card);
2167         return 0;
2168 }
2169
2170
2171 static void lower_callback(unsigned int cmd, u32 contr, void *data)
2172 {
2173
2174         switch (cmd) {
2175         case KCI_CONTRUP:
2176                 printk(KERN_INFO "capidrv: controller %hu up\n", contr);
2177                 (void) capidrv_addcontr(contr, (capi_profile *) data);
2178                 break;
2179         case KCI_CONTRDOWN:
2180                 printk(KERN_INFO "capidrv: controller %hu down\n", contr);
2181                 (void) capidrv_delcontr(contr);
2182                 break;
2183         }
2184 }
2185
2186 /*
2187  * /proc/capi/capidrv:
2188  * nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt
2189  */
2190 static int proc_capidrv_read_proc(char *page, char **start, off_t off,
2191                                        int count, int *eof, void *data)
2192 {
2193         int len = 0;
2194
2195         len += sprintf(page+len, "%lu %lu %lu %lu\n",
2196                         global.ap.nrecvctlpkt,
2197                         global.ap.nrecvdatapkt,
2198                         global.ap.nsentctlpkt,
2199                         global.ap.nsentdatapkt);
2200         if (off+count >= len)
2201            *eof = 1;
2202         if (len < off)
2203            return 0;
2204         *start = page + off;
2205         return ((count < len-off) ? count : len-off);
2206 }
2207
2208 static struct procfsentries {
2209   char *name;
2210   mode_t mode;
2211   int (*read_proc)(char *page, char **start, off_t off,
2212                                        int count, int *eof, void *data);
2213   struct proc_dir_entry *procent;
2214 } procfsentries[] = {
2215    /* { "capi",           S_IFDIR, 0 }, */
2216    { "capi/capidrv",      0      , proc_capidrv_read_proc },
2217 };
2218
2219 static void __init proc_init(void)
2220 {
2221     int nelem = sizeof(procfsentries)/sizeof(procfsentries[0]);
2222     int i;
2223
2224     for (i=0; i < nelem; i++) {
2225         struct procfsentries *p = procfsentries + i;
2226         p->procent = create_proc_entry(p->name, p->mode, NULL);
2227         if (p->procent) p->procent->read_proc = p->read_proc;
2228     }
2229 }
2230
2231 static void __exit proc_exit(void)
2232 {
2233     int nelem = sizeof(procfsentries)/sizeof(procfsentries[0]);
2234     int i;
2235
2236     for (i=nelem-1; i >= 0; i--) {
2237         struct procfsentries *p = procfsentries + i;
2238         if (p->procent) {
2239            remove_proc_entry(p->name, NULL);
2240            p->procent = NULL;
2241         }
2242     }
2243 }
2244
2245 static int __init capidrv_init(void)
2246 {
2247         capi_profile profile;
2248         char rev[32];
2249         char *p;
2250         u32 ncontr, contr;
2251         u16 errcode;
2252
2253         if ((p = strchr(revision, ':')) != 0 && p[1]) {
2254                 strncpy(rev, p + 2, sizeof(rev));
2255                 rev[sizeof(rev)-1] = 0;
2256                 if ((p = strchr(rev, '$')) != 0 && p > rev)
2257                    *(p-1) = 0;
2258         } else
2259                 strcpy(rev, "1.0");
2260
2261         global.ap.rparam.level3cnt = -2;  /* number of bchannels twice */
2262         global.ap.rparam.datablkcnt = 16;
2263         global.ap.rparam.datablklen = 2048;
2264
2265         global.ap.recv_message = capidrv_recv_message;
2266         errcode = capi20_register(&global.ap);
2267         if (errcode) {
2268                 return -EIO;
2269         }
2270
2271         capi20_set_callback(&global.ap, lower_callback);
2272
2273         errcode = capi20_get_profile(0, &profile);
2274         if (errcode != CAPI_NOERROR) {
2275                 capi20_release(&global.ap);
2276                 return -EIO;
2277         }
2278
2279         ncontr = profile.ncontroller;
2280         for (contr = 1; contr <= ncontr; contr++) {
2281                 errcode = capi20_get_profile(contr, &profile);
2282                 if (errcode != CAPI_NOERROR)
2283                         continue;
2284                 (void) capidrv_addcontr(contr, &profile);
2285         }
2286         proc_init();
2287
2288         printk(KERN_NOTICE "capidrv: Rev %s: loaded\n", rev);
2289         return 0;
2290 }
2291
2292 static void __exit capidrv_exit(void)
2293 {
2294         char rev[10];
2295         char *p;
2296
2297         if ((p = strchr(revision, ':')) != 0) {
2298                 strcpy(rev, p + 1);
2299                 p = strchr(rev, '$');
2300                 *p = 0;
2301         } else {
2302                 strcpy(rev, " ??? ");
2303         }
2304
2305         capi20_release(&global.ap);
2306
2307         proc_exit();
2308
2309         printk(KERN_NOTICE "capidrv: Rev%s: unloaded\n", rev);
2310 }
2311
2312 module_init(capidrv_init);
2313 module_exit(capidrv_exit);