?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / drivers / isdn / capi / capidrv.c
blobe8949f3dcae17712cae36973804f90d8602ca3b4
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/compiler.h>
13 #include <linux/module.h>
14 #include <linux/errno.h>
15 #include <linux/kernel.h>
16 #include <linux/major.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/seq_file.h>
29 #include <linux/capi.h>
30 #include <linux/kernelcapi.h>
31 #include <linux/ctype.h>
32 #include <linux/init.h>
33 #include <linux/moduleparam.h>
34
35 #include <linux/isdn/capiutil.h>
36 #include <linux/isdn/capicmd.h>
37 #include "capidrv.h"
38
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, S_IRUGO | S_IWUSR);
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 == NULL)
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 == NULL)
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)) == NULL)
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)) == NULL)
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 = kmalloc(sizeof(struct ncci_datahandle_queue), GFP_ATOMIC);
474 if (!n) {
475 printk(KERN_ERR "capidrv: kmalloc ncci_datahandle failed\n");
476 return -1;
477 }
478 n->next = NULL;
479 n->datahandle = datahandle;
480 n->len = len;
481 for (pp = &nccip->ackqueue; *pp; pp = &(*pp)->next);
482 *pp = n;
483 return 0;
484 }
485
486 static int capidrv_del_ack(struct capidrv_ncci *nccip, u16 datahandle)
487 {
488 struct ncci_datahandle_queue **pp, *p;
489 int len;
490
491 for (pp = &nccip->ackqueue; *pp; pp = &(*pp)->next) {
492 if ((*pp)->datahandle == datahandle) {
493 p = *pp;
494 len = p->len;
495 *pp = (*pp)->next;
496 kfree(p);
497 return len;
498 }
499 }
500 return -1;
501 }
502
503 /* -------- convert and send capi message ---------------------------- */
504
505 static void send_message(capidrv_contr *card, _cmsg *cmsg)
506 {
507 struct sk_buff *skb;
508 size_t len;
509
510 if (capi_cmsg2message(cmsg, cmsg->buf)) {
511 printk(KERN_ERR "capidrv::send_message: parser failure\n");
512 return;
513 }
514 len = CAPIMSG_LEN(cmsg->buf);
515 skb = alloc_skb(len, GFP_ATOMIC);
516 if (!skb) {
517 printk(KERN_ERR "capidrv::send_message: can't allocate mem\n");
518 return;
519 }
520 skb_put_data(skb, cmsg->buf, len);
521 if (capi20_put_message(&global.ap, skb) != CAPI_NOERROR)
522 kfree_skb(skb);
523 }
524
525 /* -------- state machine -------------------------------------------- */
526
527 struct listenstatechange {
528 int actstate;
529 int nextstate;
530 int event;
531 };
532
533 static struct listenstatechange listentable[] =
534 {
535 {ST_LISTEN_NONE, ST_LISTEN_WAIT_CONF, EV_LISTEN_REQ},
536 {ST_LISTEN_ACTIVE, ST_LISTEN_ACTIVE_WAIT_CONF, EV_LISTEN_REQ},
537 {ST_LISTEN_WAIT_CONF, ST_LISTEN_NONE, EV_LISTEN_CONF_ERROR},
538 {ST_LISTEN_ACTIVE_WAIT_CONF, ST_LISTEN_ACTIVE, EV_LISTEN_CONF_ERROR},
539 {ST_LISTEN_WAIT_CONF, ST_LISTEN_NONE, EV_LISTEN_CONF_EMPTY},
540 {ST_LISTEN_ACTIVE_WAIT_CONF, ST_LISTEN_NONE, EV_LISTEN_CONF_EMPTY},
541 {ST_LISTEN_WAIT_CONF, ST_LISTEN_ACTIVE, EV_LISTEN_CONF_OK},
542 {ST_LISTEN_ACTIVE_WAIT_CONF, ST_LISTEN_ACTIVE, EV_LISTEN_CONF_OK},
543 {},
544 };
545
546 static void listen_change_state(capidrv_contr *card, int event)
547 {
548 struct listenstatechange *p = listentable;
549 while (p->event) {
550 if (card->state == p->actstate && p->event == event) {
551 if (debugmode)
552 printk(KERN_DEBUG "capidrv-%d: listen_change_state %d -> %d\n",
553 card->contrnr, card->state, p->nextstate);
554 card->state = p->nextstate;
555 return;
556 }
557 p++;
558 }
559 printk(KERN_ERR "capidrv-%d: listen_change_state state=%d event=%d ????\n",
560 card->contrnr, card->state, event);
561
562 }
563
564 /* ------------------------------------------------------------------ */
565
566 static void p0(capidrv_contr *card, capidrv_plci *plci)
567 {
568 isdn_ctrl cmd;
569
570 card->bchans[plci->chan].contr = NULL;
571 cmd.command = ISDN_STAT_DHUP;
572 cmd.driver = card->myid;
573 cmd.arg = plci->chan;
574 card->interface.statcallb(&cmd);
575 free_plci(card, plci);
576 }
577
578 /* ------------------------------------------------------------------ */
579
580 struct plcistatechange {
581 int actstate;
582 int nextstate;
583 int event;
584 void (*changefunc)(capidrv_contr *card, capidrv_plci *plci);
585 };
586
587 static struct plcistatechange plcitable[] =
588 {
589 /* P-0 */
590 {ST_PLCI_NONE, ST_PLCI_OUTGOING, EV_PLCI_CONNECT_REQ, NULL},
591 {ST_PLCI_NONE, ST_PLCI_ALLOCATED, EV_PLCI_FACILITY_IND_UP, NULL},
592 {ST_PLCI_NONE, ST_PLCI_INCOMING, EV_PLCI_CONNECT_IND, NULL},
593 {ST_PLCI_NONE, ST_PLCI_RESUMEING, EV_PLCI_RESUME_REQ, NULL},
594 /* P-0.1 */
595 {ST_PLCI_OUTGOING, ST_PLCI_NONE, EV_PLCI_CONNECT_CONF_ERROR, p0},
596 {ST_PLCI_OUTGOING, ST_PLCI_ALLOCATED, EV_PLCI_CONNECT_CONF_OK, NULL},
597 /* P-1 */
598 {ST_PLCI_ALLOCATED, ST_PLCI_ACTIVE, EV_PLCI_CONNECT_ACTIVE_IND, NULL},
599 {ST_PLCI_ALLOCATED, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, NULL},
600 {ST_PLCI_ALLOCATED, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, NULL},
601 {ST_PLCI_ALLOCATED, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
602 /* P-ACT */
603 {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, NULL},
604 {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, NULL},
605 {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
606 {ST_PLCI_ACTIVE, ST_PLCI_HELD, EV_PLCI_HOLD_IND, NULL},
607 {ST_PLCI_ACTIVE, ST_PLCI_DISCONNECTING, EV_PLCI_SUSPEND_IND, NULL},
608 /* P-2 */
609 {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_CONNECT_REJECT, NULL},
610 {ST_PLCI_INCOMING, ST_PLCI_FACILITY_IND, EV_PLCI_FACILITY_IND_UP, NULL},
611 {ST_PLCI_INCOMING, ST_PLCI_ACCEPTING, EV_PLCI_CONNECT_RESP, NULL},
612 {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, NULL},
613 {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, NULL},
614 {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
615 {ST_PLCI_INCOMING, ST_PLCI_DISCONNECTING, EV_PLCI_CD_IND, NULL},
616 /* P-3 */
617 {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTING, EV_PLCI_CONNECT_REJECT, NULL},
618 {ST_PLCI_FACILITY_IND, ST_PLCI_ACCEPTING, EV_PLCI_CONNECT_ACTIVE_IND, NULL},
619 {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, NULL},
620 {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, NULL},
621 {ST_PLCI_FACILITY_IND, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
622 /* P-4 */
623 {ST_PLCI_ACCEPTING, ST_PLCI_ACTIVE, EV_PLCI_CONNECT_ACTIVE_IND, NULL},
624 {ST_PLCI_ACCEPTING, ST_PLCI_DISCONNECTING, EV_PLCI_DISCONNECT_REQ, NULL},
625 {ST_PLCI_ACCEPTING, ST_PLCI_DISCONNECTING, EV_PLCI_FACILITY_IND_DOWN, NULL},
626 {ST_PLCI_ACCEPTING, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
627 /* P-5 */
628 {ST_PLCI_DISCONNECTING, ST_PLCI_DISCONNECTED, EV_PLCI_DISCONNECT_IND, NULL},
629 /* P-6 */
630 {ST_PLCI_DISCONNECTED, ST_PLCI_NONE, EV_PLCI_DISCONNECT_RESP, p0},
631 /* P-0.Res */
632 {ST_PLCI_RESUMEING, ST_PLCI_NONE, EV_PLCI_RESUME_CONF_ERROR, p0},
633 {ST_PLCI_RESUMEING, ST_PLCI_RESUME, EV_PLCI_RESUME_CONF_OK, NULL},
634 /* P-RES */
635 {ST_PLCI_RESUME, ST_PLCI_ACTIVE, EV_PLCI_RESUME_IND, NULL},
636 /* P-HELD */
637 {ST_PLCI_HELD, ST_PLCI_ACTIVE, EV_PLCI_RETRIEVE_IND, NULL},
638 {},
639 };
640
641 static void plci_change_state(capidrv_contr *card, capidrv_plci *plci, int event)
642 {
643 struct plcistatechange *p = plcitable;
644 while (p->event) {
645 if (plci->state == p->actstate && p->event == event) {
646 if (debugmode)
647 printk(KERN_DEBUG "capidrv-%d: plci_change_state:0x%x %d -> %d\n",
648 card->contrnr, plci->plci, plci->state, p->nextstate);
649 plci->state = p->nextstate;
650 if (p->changefunc)
651 p->changefunc(card, plci);
652 return;
653 }
654 p++;
655 }
656 printk(KERN_ERR "capidrv-%d: plci_change_state:0x%x state=%d event=%d ????\n",
657 card->contrnr, plci->plci, plci->state, event);
658 }
659
660 /* ------------------------------------------------------------------ */
661
662 static _cmsg cmsg;
663
664 static void n0(capidrv_contr *card, capidrv_ncci *ncci)
665 {
666 isdn_ctrl cmd;
667
668 capi_fill_DISCONNECT_REQ(&cmsg,
669 global.ap.applid,
670 card->msgid++,
671 ncci->plcip->plci,
672 NULL, /* BChannelinformation */
673 NULL, /* Keypadfacility */
674 NULL, /* Useruserdata */ /* $$$$ */
675 NULL /* Facilitydataarray */
676 );
677 plci_change_state(card, ncci->plcip, EV_PLCI_DISCONNECT_REQ);
678 send_message(card, &cmsg);
679
680 cmd.command = ISDN_STAT_BHUP;
681 cmd.driver = card->myid;
682 cmd.arg = ncci->chan;
683 card->interface.statcallb(&cmd);
684 free_ncci(card, ncci);
685 }
686
687 /* ------------------------------------------------------------------ */
688
689 struct nccistatechange {
690 int actstate;
691 int nextstate;
692 int event;
693 void (*changefunc)(capidrv_contr *card, capidrv_ncci *ncci);
694 };
695
696 static struct nccistatechange nccitable[] =
697 {
698 /* N-0 */
699 {ST_NCCI_NONE, ST_NCCI_OUTGOING, EV_NCCI_CONNECT_B3_REQ, NULL},
700 {ST_NCCI_NONE, ST_NCCI_INCOMING, EV_NCCI_CONNECT_B3_IND, NULL},
701 /* N-0.1 */
702 {ST_NCCI_OUTGOING, ST_NCCI_ALLOCATED, EV_NCCI_CONNECT_B3_CONF_OK, NULL},
703 {ST_NCCI_OUTGOING, ST_NCCI_NONE, EV_NCCI_CONNECT_B3_CONF_ERROR, n0},
704 /* N-1 */
705 {ST_NCCI_INCOMING, ST_NCCI_DISCONNECTING, EV_NCCI_CONNECT_B3_REJECT, NULL},
706 {ST_NCCI_INCOMING, ST_NCCI_ALLOCATED, EV_NCCI_CONNECT_B3_RESP, NULL},
707 {ST_NCCI_INCOMING, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, NULL},
708 {ST_NCCI_INCOMING, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, NULL},
709 /* N-2 */
710 {ST_NCCI_ALLOCATED, ST_NCCI_ACTIVE, EV_NCCI_CONNECT_B3_ACTIVE_IND, NULL},
711 {ST_NCCI_ALLOCATED, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, NULL},
712 {ST_NCCI_ALLOCATED, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, NULL},
713 /* N-ACT */
714 {ST_NCCI_ACTIVE, ST_NCCI_ACTIVE, EV_NCCI_RESET_B3_IND, NULL},
715 {ST_NCCI_ACTIVE, ST_NCCI_RESETING, EV_NCCI_RESET_B3_REQ, NULL},
716 {ST_NCCI_ACTIVE, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, NULL},
717 {ST_NCCI_ACTIVE, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, NULL},
718 /* N-3 */
719 {ST_NCCI_RESETING, ST_NCCI_ACTIVE, EV_NCCI_RESET_B3_IND, NULL},
720 {ST_NCCI_RESETING, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, NULL},
721 {ST_NCCI_RESETING, ST_NCCI_DISCONNECTING, EV_NCCI_DISCONNECT_B3_REQ, NULL},
722 /* N-4 */
723 {ST_NCCI_DISCONNECTING, ST_NCCI_DISCONNECTED, EV_NCCI_DISCONNECT_B3_IND, NULL},
724 {ST_NCCI_DISCONNECTING, ST_NCCI_PREVIOUS, EV_NCCI_DISCONNECT_B3_CONF_ERROR, NULL},
725 /* N-5 */
726 {ST_NCCI_DISCONNECTED, ST_NCCI_NONE, EV_NCCI_DISCONNECT_B3_RESP, n0},
727 {},
728 };
729
730 static void ncci_change_state(capidrv_contr *card, capidrv_ncci *ncci, int event)
731 {
732 struct nccistatechange *p = nccitable;
733 while (p->event) {
734 if (ncci->state == p->actstate && p->event == event) {
735 if (debugmode)
736 printk(KERN_DEBUG "capidrv-%d: ncci_change_state:0x%x %d -> %d\n",
737 card->contrnr, ncci->ncci, ncci->state, p->nextstate);
738 if (p->nextstate == ST_NCCI_PREVIOUS) {
739 ncci->state = ncci->oldstate;
740 ncci->oldstate = p->actstate;
741 } else {
742 ncci->oldstate = p->actstate;
743 ncci->state = p->nextstate;
744 }
745 if (p->changefunc)
746 p->changefunc(card, ncci);
747 return;
748 }
749 p++;
750 }
751 printk(KERN_ERR "capidrv-%d: ncci_change_state:0x%x state=%d event=%d ????\n",
752 card->contrnr, ncci->ncci, ncci->state, event);
753 }
754
755 /* ------------------------------------------------------------------- */
756
757 static inline int new_bchan(capidrv_contr *card)
758 {
759 int i;
760 for (i = 0; i < card->nbchan; i++) {
761 if (card->bchans[i].plcip == NULL) {
762 card->bchans[i].disconnecting = 0;
763 return i;
764 }
765 }
766 return -1;
767 }
768
769 /* ------------------------------------------------------------------- */
770 static char *capi_info2str(u16 reason)
771 {
772 #ifndef CONFIG_ISDN_CAPI_CAPIDRV_VERBOSE
773 return "..";
774 #else
775 switch (reason) {
776
777 /*-- informative values (corresponding message was processed) -----*/
778 case 0x0001:
779 return "NCPI not supported by current protocol, NCPI ignored";
780 case 0x0002:
781 return "Flags not supported by current protocol, flags ignored";
782 case 0x0003:
783 return "Alert already sent by another application";
784
785 /*-- error information concerning CAPI_REGISTER -----*/
786 case 0x1001:
787 return "Too many applications";
788 case 0x1002:
789 return "Logical block size too small, must be at least 128 Bytes";
790 case 0x1003:
791 return "Buffer exceeds 64 kByte";
792 case 0x1004:
793 return "Message buffer size too small, must be at least 1024 Bytes";
794 case 0x1005:
795 return "Max. number of logical connections not supported";
796 case 0x1006:
797 return "Reserved";
798 case 0x1007:
799 return "The message could not be accepted because of an internal busy condition";
800 case 0x1008:
801 return "OS resource error (no memory ?)";
802 case 0x1009:
803 return "CAPI not installed";
804 case 0x100A:
805 return "Controller does not support external equipment";
806 case 0x100B:
807 return "Controller does only support external equipment";
808
809 /*-- error information concerning message exchange functions -----*/
810 case 0x1101:
811 return "Illegal application number";
812 case 0x1102:
813 return "Illegal command or subcommand or message length less than 12 bytes";
814 case 0x1103:
815 return "The message could not be accepted because of a queue full condition !! The error code does not imply that CAPI cannot receive messages directed to another controller, PLCI or NCCI";
816 case 0x1104:
817 return "Queue is empty";
818 case 0x1105:
819 return "Queue overflow, a message was lost !! This indicates a configuration error. The only recovery from this error is to perform a CAPI_RELEASE";
820 case 0x1106:
821 return "Unknown notification parameter";
822 case 0x1107:
823 return "The Message could not be accepted because of an internal busy condition";
824 case 0x1108:
825 return "OS Resource error (no memory ?)";
826 case 0x1109:
827 return "CAPI not installed";
828 case 0x110A:
829 return "Controller does not support external equipment";
830 case 0x110B:
831 return "Controller does only support external equipment";
832
833 /*-- error information concerning resource / coding problems -----*/
834 case 0x2001:
835 return "Message not supported in current state";
836 case 0x2002:
837 return "Illegal Controller / PLCI / NCCI";
838 case 0x2003:
839 return "Out of PLCI";
840 case 0x2004:
841 return "Out of NCCI";
842 case 0x2005:
843 return "Out of LISTEN";
844 case 0x2006:
845 return "Out of FAX resources (protocol T.30)";
846 case 0x2007:
847 return "Illegal message parameter coding";
848
849 /*-- error information concerning requested services -----*/
850 case 0x3001:
851 return "B1 protocol not supported";
852 case 0x3002:
853 return "B2 protocol not supported";
854 case 0x3003:
855 return "B3 protocol not supported";
856 case 0x3004:
857 return "B1 protocol parameter not supported";
858 case 0x3005:
859 return "B2 protocol parameter not supported";
860 case 0x3006:
861 return "B3 protocol parameter not supported";
862 case 0x3007:
863 return "B protocol combination not supported";
864 case 0x3008:
865 return "NCPI not supported";
866 case 0x3009:
867 return "CIP Value unknown";
868 case 0x300A:
869 return "Flags not supported (reserved bits)";
870 case 0x300B:
871 return "Facility not supported";
872 case 0x300C:
873 return "Data length not supported by current protocol";
874 case 0x300D:
875 return "Reset procedure not supported by current protocol";
876
877 /*-- informations about the clearing of a physical connection -----*/
878 case 0x3301:
879 return "Protocol error layer 1 (broken line or B-channel removed by signalling protocol)";
880 case 0x3302:
881 return "Protocol error layer 2";
882 case 0x3303:
883 return "Protocol error layer 3";
884 case 0x3304:
885 return "Another application got that call";
886 /*-- T.30 specific reasons -----*/
887 case 0x3311:
888 return "Connecting not successful (remote station is no FAX G3 machine)";
889 case 0x3312:
890 return "Connecting not successful (training error)";
891 case 0x3313:
892 return "Disconnected before transfer (remote station does not support transfer mode, e.g. resolution)";
893 case 0x3314:
894 return "Disconnected during transfer (remote abort)";
895 case 0x3315:
896 return "Disconnected during transfer (remote procedure error, e.g. unsuccessful repetition of T.30 commands)";
897 case 0x3316:
898 return "Disconnected during transfer (local tx data underrun)";
899 case 0x3317:
900 return "Disconnected during transfer (local rx data overflow)";
901 case 0x3318:
902 return "Disconnected during transfer (local abort)";
903 case 0x3319:
904 return "Illegal parameter coding (e.g. SFF coding error)";
905
906 /*-- disconnect causes from the network according to ETS 300 102-1/Q.931 -----*/
907 case 0x3481: return "Unallocated (unassigned) number";
908 case 0x3482: return "No route to specified transit network";
909 case 0x3483: return "No route to destination";
910 case 0x3486: return "Channel unacceptable";
911 case 0x3487:
912 return "Call awarded and being delivered in an established channel";
913 case 0x3490: return "Normal call clearing";
914 case 0x3491: return "User busy";
915 case 0x3492: return "No user responding";
916 case 0x3493: return "No answer from user (user alerted)";
917 case 0x3495: return "Call rejected";
918 case 0x3496: return "Number changed";
919 case 0x349A: return "Non-selected user clearing";
920 case 0x349B: return "Destination out of order";
921 case 0x349C: return "Invalid number format";
922 case 0x349D: return "Facility rejected";
923 case 0x349E: return "Response to STATUS ENQUIRY";
924 case 0x349F: return "Normal, unspecified";
925 case 0x34A2: return "No circuit / channel available";
926 case 0x34A6: return "Network out of order";
927 case 0x34A9: return "Temporary failure";
928 case 0x34AA: return "Switching equipment congestion";
929 case 0x34AB: return "Access information discarded";
930 case 0x34AC: return "Requested circuit / channel not available";
931 case 0x34AF: return "Resources unavailable, unspecified";
932 case 0x34B1: return "Quality of service unavailable";
933 case 0x34B2: return "Requested facility not subscribed";
934 case 0x34B9: return "Bearer capability not authorized";
935 case 0x34BA: return "Bearer capability not presently available";
936 case 0x34BF: return "Service or option not available, unspecified";
937 case 0x34C1: return "Bearer capability not implemented";
938 case 0x34C2: return "Channel type not implemented";
939 case 0x34C5: return "Requested facility not implemented";
940 case 0x34C6: return "Only restricted digital information bearer capability is available";
941 case 0x34CF: return "Service or option not implemented, unspecified";
942 case 0x34D1: return "Invalid call reference value";
943 case 0x34D2: return "Identified channel does not exist";
944 case 0x34D3: return "A suspended call exists, but this call identity does not";
945 case 0x34D4: return "Call identity in use";
946 case 0x34D5: return "No call suspended";
947 case 0x34D6: return "Call having the requested call identity has been cleared";
948 case 0x34D8: return "Incompatible destination";
949 case 0x34DB: return "Invalid transit network selection";
950 case 0x34DF: return "Invalid message, unspecified";
951 case 0x34E0: return "Mandatory information element is missing";
952 case 0x34E1: return "Message type non-existent or not implemented";
953 case 0x34E2: return "Message not compatible with call state or message type non-existent or not implemented";
954 case 0x34E3: return "Information element non-existent or not implemented";
955 case 0x34E4: return "Invalid information element contents";
956 case 0x34E5: return "Message not compatible with call state";
957 case 0x34E6: return "Recovery on timer expiry";
958 case 0x34EF: return "Protocol error, unspecified";
959 case 0x34FF: return "Interworking, unspecified";
960
961 default: return "No additional information";
962 }
963 #endif
964 }
965
966 static void handle_controller(_cmsg *cmsg)
967 {
968 capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
969
970 if (!card) {
971 printk(KERN_ERR "capidrv: %s from unknown controller 0x%x\n",
972 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
973 cmsg->adr.adrController & 0x7f);
974 return;
975 }
976 switch (CAPICMD(cmsg->Command, cmsg->Subcommand)) {
977
978 case CAPI_LISTEN_CONF: /* Controller */
979 if (debugmode)
980 printk(KERN_DEBUG "capidrv-%d: listenconf Info=0x%4x (%s) cipmask=0x%x\n",
981 card->contrnr, cmsg->Info, capi_info2str(cmsg->Info), card->cipmask);
982 if (cmsg->Info) {
983 listen_change_state(card, EV_LISTEN_CONF_ERROR);
984 } else if (card->cipmask == 0) {
985 listen_change_state(card, EV_LISTEN_CONF_EMPTY);
986 } else {
987 listen_change_state(card, EV_LISTEN_CONF_OK);
988 }
989 break;
990
991 case CAPI_MANUFACTURER_IND: /* Controller */
992 if (cmsg->ManuID == 0x214D5641
993 && cmsg->Class == 0
994 && cmsg->Function == 1) {
995 u8 *data = cmsg->ManuData + 3;
996 u16 len = cmsg->ManuData[0];
997 u16 layer;
998 int direction;
999 if (len == 255) {
1000 len = (cmsg->ManuData[1] | (cmsg->ManuData[2] << 8));
1001 data += 2;
1002 }
1003 len -= 2;
1004 layer = ((*(data - 1)) << 8) | *(data - 2);
1005 if (layer & 0x300)
1006 direction = (layer & 0x200) ? 0 : 1;
1007 else direction = (layer & 0x800) ? 0 : 1;
1008 if (layer & 0x0C00) {
1009 if ((layer & 0xff) == 0x80) {
1010 handle_dtrace_data(card, direction, 1, data, len);
1011 break;
1012 }
1013 } else if ((layer & 0xff) < 0x80) {
1014 handle_dtrace_data(card, direction, 0, data, len);
1015 break;
1016 }
1017 printk(KERN_INFO "capidrv-%d: %s from controller 0x%x layer 0x%x, ignored\n",
1018 card->contrnr,
1019 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1020 cmsg->adr.adrController, layer);
1021 break;
1022 }
1023 goto ignored;
1024 case CAPI_MANUFACTURER_CONF: /* Controller */
1025 if (cmsg->ManuID == 0x214D5641) {
1026 char *s = NULL;
1027 switch (cmsg->Class) {
1028 case 0: break;
1029 case 1: s = "unknown class"; break;
1030 case 2: s = "unknown function"; break;
1031 default: s = "unknown error"; break;
1032 }
1033 if (s)
1034 printk(KERN_INFO "capidrv-%d: %s from controller 0x%x function %d: %s\n",
1035 card->contrnr,
1036 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1037 cmsg->adr.adrController,
1038 cmsg->Function, s);
1039 break;
1040 }
1041 goto ignored;
1042 case CAPI_FACILITY_IND: /* Controller/plci/ncci */
1043 goto ignored;
1044 case CAPI_FACILITY_CONF: /* Controller/plci/ncci */
1045 goto ignored;
1046 case CAPI_INFO_IND: /* Controller/plci */
1047 goto ignored;
1048 case CAPI_INFO_CONF: /* Controller/plci */
1049 goto ignored;
1050
1051 default:
1052 printk(KERN_ERR "capidrv-%d: got %s from controller 0x%x ???",
1053 card->contrnr,
1054 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1055 cmsg->adr.adrController);
1056 }
1057 return;
1058
1059 ignored:
1060 printk(KERN_INFO "capidrv-%d: %s from controller 0x%x ignored\n",
1061 card->contrnr,
1062 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1063 cmsg->adr.adrController);
1064 }
1065
1066 static void handle_incoming_call(capidrv_contr *card, _cmsg *cmsg)
1067 {
1068 capidrv_plci *plcip;
1069 capidrv_bchan *bchan;
1070 isdn_ctrl cmd;
1071 int chan;
1072
1073 if ((chan = new_bchan(card)) == -1) {
1074 printk(KERN_ERR "capidrv-%d: incoming call on not existing bchan ?\n", card->contrnr);
1075 return;
1076 }
1077 bchan = &card->bchans[chan];
1078 if ((plcip = new_plci(card, chan)) == NULL) {
1079 printk(KERN_ERR "capidrv-%d: incoming call: no memory, sorry.\n", card->contrnr);
1080 return;
1081 }
1082 bchan->incoming = 1;
1083 plcip->plci = cmsg->adr.adrPLCI;
1084 plci_change_state(card, plcip, EV_PLCI_CONNECT_IND);
1085
1086 cmd.command = ISDN_STAT_ICALL;
1087 cmd.driver = card->myid;
1088 cmd.arg = chan;
1089 memset(&cmd.parm.setup, 0, sizeof(cmd.parm.setup));
1090 strncpy(cmd.parm.setup.phone,
1091 cmsg->CallingPartyNumber + 3,
1092 cmsg->CallingPartyNumber[0] - 2);
1093 strncpy(cmd.parm.setup.eazmsn,
1094 cmsg->CalledPartyNumber + 2,
1095 cmsg->CalledPartyNumber[0] - 1);
1096 cmd.parm.setup.si1 = cip2si1(cmsg->CIPValue);
1097 cmd.parm.setup.si2 = cip2si2(cmsg->CIPValue);
1098 cmd.parm.setup.plan = cmsg->CallingPartyNumber[1];
1099 cmd.parm.setup.screen = cmsg->CallingPartyNumber[2];
1100
1101 printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s\n",
1102 card->contrnr,
1103 cmd.parm.setup.phone,
1104 cmd.parm.setup.si1,
1105 cmd.parm.setup.si2,
1106 cmd.parm.setup.eazmsn);
1107
1108 if (cmd.parm.setup.si1 == 1 && cmd.parm.setup.si2 != 0) {
1109 printk(KERN_INFO "capidrv-%d: patching si2=%d to 0 for VBOX\n",
1110 card->contrnr,
1111 cmd.parm.setup.si2);
1112 cmd.parm.setup.si2 = 0;
1113 }
1114
1115 switch (card->interface.statcallb(&cmd)) {
1116 case 0:
1117 case 3:
1118 /* No device matching this call.
1119 * and isdn_common.c has send a HANGUP command
1120 * which is ignored in state ST_PLCI_INCOMING,
1121 * so we send RESP to ignore the call
1122 */
1123 capi_cmsg_answer(cmsg);
1124 cmsg->Reject = 1; /* ignore */
1125 plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT);
1126 send_message(card, cmsg);
1127 printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s ignored\n",
1128 card->contrnr,
1129 cmd.parm.setup.phone,
1130 cmd.parm.setup.si1,
1131 cmd.parm.setup.si2,
1132 cmd.parm.setup.eazmsn);
1133 break;
1134 case 1:
1135 /* At least one device matching this call (RING on ttyI)
1136 * HL-driver may send ALERTING on the D-channel in this
1137 * case.
1138 * really means: RING on ttyI or a net interface
1139 * accepted this call already.
1140 *
1141 * If the call was accepted, state has already changed,
1142 * and CONNECT_RESP already sent.
1143 */
1144 if (plcip->state == ST_PLCI_INCOMING) {
1145 printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s tty alerting\n",
1146 card->contrnr,
1147 cmd.parm.setup.phone,
1148 cmd.parm.setup.si1,
1149 cmd.parm.setup.si2,
1150 cmd.parm.setup.eazmsn);
1151 capi_fill_ALERT_REQ(cmsg,
1152 global.ap.applid,
1153 card->msgid++,
1154 plcip->plci, /* adr */
1155 NULL,/* BChannelinformation */
1156 NULL,/* Keypadfacility */
1157 NULL,/* Useruserdata */
1158 NULL /* Facilitydataarray */
1159 );
1160 plcip->msgid = cmsg->Messagenumber;
1161 send_message(card, cmsg);
1162 } else {
1163 printk(KERN_INFO "capidrv-%d: incoming call %s,%d,%d,%s on netdev\n",
1164 card->contrnr,
1165 cmd.parm.setup.phone,
1166 cmd.parm.setup.si1,
1167 cmd.parm.setup.si2,
1168 cmd.parm.setup.eazmsn);
1169 }
1170 break;
1171
1172 case 2: /* Call will be rejected. */
1173 capi_cmsg_answer(cmsg);
1174 cmsg->Reject = 2; /* reject call, normal call clearing */
1175 plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT);
1176 send_message(card, cmsg);
1177 break;
1178
1179 default:
1180 /* An error happened. (Invalid parameters for example.) */
1181 capi_cmsg_answer(cmsg);
1182 cmsg->Reject = 8; /* reject call,
1183 destination out of order */
1184 plci_change_state(card, plcip, EV_PLCI_CONNECT_REJECT);
1185 send_message(card, cmsg);
1186 break;
1187 }
1188 return;
1189 }
1190
1191 static void handle_plci(_cmsg *cmsg)
1192 {
1193 capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
1194 capidrv_plci *plcip;
1195 isdn_ctrl cmd;
1196 _cdebbuf *cdb;
1197
1198 if (!card) {
1199 printk(KERN_ERR "capidrv: %s from unknown controller 0x%x\n",
1200 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1201 cmsg->adr.adrController & 0x7f);
1202 return;
1203 }
1204 switch (CAPICMD(cmsg->Command, cmsg->Subcommand)) {
1205
1206 case CAPI_DISCONNECT_IND: /* plci */
1207 if (cmsg->Reason) {
1208 printk(KERN_INFO "capidrv-%d: %s reason 0x%x (%s) for plci 0x%x\n",
1209 card->contrnr,
1210 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1211 cmsg->Reason, capi_info2str(cmsg->Reason), cmsg->adr.adrPLCI);
1212 }
1213 if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI))) {
1214 capi_cmsg_answer(cmsg);
1215 send_message(card, cmsg);
1216 goto notfound;
1217 }
1218 card->bchans[plcip->chan].disconnecting = 1;
1219 plci_change_state(card, plcip, EV_PLCI_DISCONNECT_IND);
1220 capi_cmsg_answer(cmsg);
1221 plci_change_state(card, plcip, EV_PLCI_DISCONNECT_RESP);
1222 send_message(card, cmsg);
1223 break;
1224
1225 case CAPI_DISCONNECT_CONF: /* plci */
1226 if (cmsg->Info) {
1227 printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for plci 0x%x\n",
1228 card->contrnr,
1229 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1230 cmsg->Info, capi_info2str(cmsg->Info),
1231 cmsg->adr.adrPLCI);
1232 }
1233 if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI)))
1234 goto notfound;
1235
1236 card->bchans[plcip->chan].disconnecting = 1;
1237 break;
1238
1239 case CAPI_ALERT_CONF: /* plci */
1240 if (cmsg->Info) {
1241 printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for plci 0x%x\n",
1242 card->contrnr,
1243 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1244 cmsg->Info, capi_info2str(cmsg->Info),
1245 cmsg->adr.adrPLCI);
1246 }
1247 break;
1248
1249 case CAPI_CONNECT_IND: /* plci */
1250 handle_incoming_call(card, cmsg);
1251 break;
1252
1253 case CAPI_CONNECT_CONF: /* plci */
1254 if (cmsg->Info) {
1255 printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for plci 0x%x\n",
1256 card->contrnr,
1257 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1258 cmsg->Info, capi_info2str(cmsg->Info),
1259 cmsg->adr.adrPLCI);
1260 }
1261 if (!(plcip = find_plci_by_msgid(card, cmsg->Messagenumber)))
1262 goto notfound;
1263
1264 plcip->plci = cmsg->adr.adrPLCI;
1265 if (cmsg->Info) {
1266 plci_change_state(card, plcip, EV_PLCI_CONNECT_CONF_ERROR);
1267 } else {
1268 plci_change_state(card, plcip, EV_PLCI_CONNECT_CONF_OK);
1269 }
1270 break;
1271
1272 case CAPI_CONNECT_ACTIVE_IND: /* plci */
1273
1274 if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI)))
1275 goto notfound;
1276
1277 if (card->bchans[plcip->chan].incoming) {
1278 capi_cmsg_answer(cmsg);
1279 plci_change_state(card, plcip, EV_PLCI_CONNECT_ACTIVE_IND);
1280 send_message(card, cmsg);
1281 } else {
1282 capidrv_ncci *nccip;
1283 capi_cmsg_answer(cmsg);
1284 send_message(card, cmsg);
1285
1286 nccip = new_ncci(card, plcip, cmsg->adr.adrPLCI);
1287
1288 if (!nccip) {
1289 printk(KERN_ERR "capidrv-%d: no mem for ncci, sorry\n", card->contrnr);
1290 break; /* $$$$ */
1291 }
1292 capi_fill_CONNECT_B3_REQ(cmsg,
1293 global.ap.applid,
1294 card->msgid++,
1295 plcip->plci, /* adr */
1296 NULL /* NCPI */
1297 );
1298 nccip->msgid = cmsg->Messagenumber;
1299 plci_change_state(card, plcip,
1300 EV_PLCI_CONNECT_ACTIVE_IND);
1301 ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_REQ);
1302 send_message(card, cmsg);
1303 cmd.command = ISDN_STAT_DCONN;
1304 cmd.driver = card->myid;
1305 cmd.arg = plcip->chan;
1306 card->interface.statcallb(&cmd);
1307 }
1308 break;
1309
1310 case CAPI_INFO_IND: /* Controller/plci */
1311
1312 if (!(plcip = find_plci_by_plci(card, cmsg->adr.adrPLCI)))
1313 goto notfound;
1314
1315 if (cmsg->InfoNumber == 0x4000) {
1316 if (cmsg->InfoElement[0] == 4) {
1317 cmd.command = ISDN_STAT_CINF;
1318 cmd.driver = card->myid;
1319 cmd.arg = plcip->chan;
1320 sprintf(cmd.parm.num, "%lu",
1321 (unsigned long)
1322 ((u32) cmsg->InfoElement[1]
1323 | ((u32) (cmsg->InfoElement[2]) << 8)
1324 | ((u32) (cmsg->InfoElement[3]) << 16)
1325 | ((u32) (cmsg->InfoElement[4]) << 24)));
1326 card->interface.statcallb(&cmd);
1327 break;
1328 }
1329 }
1330 cdb = capi_cmsg2str(cmsg);
1331 if (cdb) {
1332 printk(KERN_WARNING "capidrv-%d: %s\n",
1333 card->contrnr, cdb->buf);
1334 cdebbuf_free(cdb);
1335 } else
1336 printk(KERN_WARNING "capidrv-%d: CAPI_INFO_IND InfoNumber %x not handled\n",
1337 card->contrnr, cmsg->InfoNumber);
1338
1339 break;
1340
1341 case CAPI_CONNECT_ACTIVE_CONF: /* plci */
1342 goto ignored;
1343 case CAPI_SELECT_B_PROTOCOL_CONF: /* plci */
1344 goto ignored;
1345 case CAPI_FACILITY_IND: /* Controller/plci/ncci */
1346 goto ignored;
1347 case CAPI_FACILITY_CONF: /* Controller/plci/ncci */
1348 goto ignored;
1349
1350 case CAPI_INFO_CONF: /* Controller/plci */
1351 goto ignored;
1352
1353 default:
1354 printk(KERN_ERR "capidrv-%d: got %s for plci 0x%x ???",
1355 card->contrnr,
1356 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1357 cmsg->adr.adrPLCI);
1358 }
1359 return;
1360 ignored:
1361 printk(KERN_INFO "capidrv-%d: %s for plci 0x%x ignored\n",
1362 card->contrnr,
1363 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1364 cmsg->adr.adrPLCI);
1365 return;
1366 notfound:
1367 printk(KERN_ERR "capidrv-%d: %s: plci 0x%x not found\n",
1368 card->contrnr,
1369 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1370 cmsg->adr.adrPLCI);
1371 return;
1372 }
1373
1374 static void handle_ncci(_cmsg *cmsg)
1375 {
1376 capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
1377 capidrv_plci *plcip;
1378 capidrv_ncci *nccip;
1379 isdn_ctrl cmd;
1380 int len;
1381
1382 if (!card) {
1383 printk(KERN_ERR "capidrv: %s from unknown controller 0x%x\n",
1384 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1385 cmsg->adr.adrController & 0x7f);
1386 return;
1387 }
1388 switch (CAPICMD(cmsg->Command, cmsg->Subcommand)) {
1389
1390 case CAPI_CONNECT_B3_ACTIVE_IND: /* ncci */
1391 if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
1392 goto notfound;
1393
1394 capi_cmsg_answer(cmsg);
1395 ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_ACTIVE_IND);
1396 send_message(card, cmsg);
1397
1398 cmd.command = ISDN_STAT_BCONN;
1399 cmd.driver = card->myid;
1400 cmd.arg = nccip->chan;
1401 card->interface.statcallb(&cmd);
1402
1403 printk(KERN_INFO "capidrv-%d: chan %d up with ncci 0x%x\n",
1404 card->contrnr, nccip->chan, nccip->ncci);
1405 break;
1406
1407 case CAPI_CONNECT_B3_ACTIVE_CONF: /* ncci */
1408 goto ignored;
1409
1410 case CAPI_CONNECT_B3_IND: /* ncci */
1411
1412 plcip = find_plci_by_ncci(card, cmsg->adr.adrNCCI);
1413 if (plcip) {
1414 nccip = new_ncci(card, plcip, cmsg->adr.adrNCCI);
1415 if (nccip) {
1416 ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_IND);
1417 capi_fill_CONNECT_B3_RESP(cmsg,
1418 global.ap.applid,
1419 card->msgid++,
1420 nccip->ncci, /* adr */
1421 0, /* Reject */
1422 NULL /* NCPI */
1423 );
1424 ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_RESP);
1425 send_message(card, cmsg);
1426 break;
1427 }
1428 printk(KERN_ERR "capidrv-%d: no mem for ncci, sorry\n", card->contrnr);
1429 } else {
1430 printk(KERN_ERR "capidrv-%d: %s: plci for ncci 0x%x not found\n",
1431 card->contrnr,
1432 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1433 cmsg->adr.adrNCCI);
1434 }
1435 capi_fill_CONNECT_B3_RESP(cmsg,
1436 global.ap.applid,
1437 card->msgid++,
1438 cmsg->adr.adrNCCI,
1439 2, /* Reject */
1440 NULL /* NCPI */
1441 );
1442 send_message(card, cmsg);
1443 break;
1444
1445 case CAPI_CONNECT_B3_CONF: /* ncci */
1446
1447 if (!(nccip = find_ncci_by_msgid(card,
1448 cmsg->adr.adrNCCI,
1449 cmsg->Messagenumber)))
1450 goto notfound;
1451
1452 nccip->ncci = cmsg->adr.adrNCCI;
1453 if (cmsg->Info) {
1454 printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for ncci 0x%x\n",
1455 card->contrnr,
1456 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1457 cmsg->Info, capi_info2str(cmsg->Info),
1458 cmsg->adr.adrNCCI);
1459 }
1460
1461 if (cmsg->Info)
1462 ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_CONF_ERROR);
1463 else
1464 ncci_change_state(card, nccip, EV_NCCI_CONNECT_B3_CONF_OK);
1465 break;
1466
1467 case CAPI_CONNECT_B3_T90_ACTIVE_IND: /* ncci */
1468 capi_cmsg_answer(cmsg);
1469 send_message(card, cmsg);
1470 break;
1471
1472 case CAPI_DATA_B3_IND: /* ncci */
1473 /* handled in handle_data() */
1474 goto ignored;
1475
1476 case CAPI_DATA_B3_CONF: /* ncci */
1477 if (cmsg->Info) {
1478 printk(KERN_WARNING "CAPI_DATA_B3_CONF: Info %x - %s\n",
1479 cmsg->Info, capi_info2str(cmsg->Info));
1480 }
1481 if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
1482 goto notfound;
1483
1484 len = capidrv_del_ack(nccip, cmsg->DataHandle);
1485 if (len < 0)
1486 break;
1487 cmd.command = ISDN_STAT_BSENT;
1488 cmd.driver = card->myid;
1489 cmd.arg = nccip->chan;
1490 cmd.parm.length = len;
1491 card->interface.statcallb(&cmd);
1492 break;
1493
1494 case CAPI_DISCONNECT_B3_IND: /* ncci */
1495 if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
1496 goto notfound;
1497
1498 card->bchans[nccip->chan].disconnecting = 1;
1499 ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_IND);
1500 capi_cmsg_answer(cmsg);
1501 ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_RESP);
1502 send_message(card, cmsg);
1503 break;
1504
1505 case CAPI_DISCONNECT_B3_CONF: /* ncci */
1506 if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
1507 goto notfound;
1508 if (cmsg->Info) {
1509 printk(KERN_INFO "capidrv-%d: %s info 0x%x (%s) for ncci 0x%x\n",
1510 card->contrnr,
1511 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1512 cmsg->Info, capi_info2str(cmsg->Info),
1513 cmsg->adr.adrNCCI);
1514 ncci_change_state(card, nccip, EV_NCCI_DISCONNECT_B3_CONF_ERROR);
1515 }
1516 break;
1517
1518 case CAPI_RESET_B3_IND: /* ncci */
1519 if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI)))
1520 goto notfound;
1521 ncci_change_state(card, nccip, EV_NCCI_RESET_B3_IND);
1522 capi_cmsg_answer(cmsg);
1523 send_message(card, cmsg);
1524 break;
1525
1526 case CAPI_RESET_B3_CONF: /* ncci */
1527 goto ignored; /* $$$$ */
1528
1529 case CAPI_FACILITY_IND: /* Controller/plci/ncci */
1530 goto ignored;
1531 case CAPI_FACILITY_CONF: /* Controller/plci/ncci */
1532 goto ignored;
1533
1534 default:
1535 printk(KERN_ERR "capidrv-%d: got %s for ncci 0x%x ???",
1536 card->contrnr,
1537 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1538 cmsg->adr.adrNCCI);
1539 }
1540 return;
1541 ignored:
1542 printk(KERN_INFO "capidrv-%d: %s for ncci 0x%x ignored\n",
1543 card->contrnr,
1544 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1545 cmsg->adr.adrNCCI);
1546 return;
1547 notfound:
1548 printk(KERN_ERR "capidrv-%d: %s: ncci 0x%x not found\n",
1549 card->contrnr,
1550 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1551 cmsg->adr.adrNCCI);
1552 }
1553
1554
1555 static void handle_data(_cmsg *cmsg, struct sk_buff *skb)
1556 {
1557 capidrv_contr *card = findcontrbynumber(cmsg->adr.adrController & 0x7f);
1558 capidrv_ncci *nccip;
1559
1560 if (!card) {
1561 printk(KERN_ERR "capidrv: %s from unknown controller 0x%x\n",
1562 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1563 cmsg->adr.adrController & 0x7f);
1564 kfree_skb(skb);
1565 return;
1566 }
1567 if (!(nccip = find_ncci(card, cmsg->adr.adrNCCI))) {
1568 printk(KERN_ERR "capidrv-%d: %s: ncci 0x%x not found\n",
1569 card->contrnr,
1570 capi_cmd2str(cmsg->Command, cmsg->Subcommand),
1571 cmsg->adr.adrNCCI);
1572 kfree_skb(skb);
1573 return;
1574 }
1575 (void) skb_pull(skb, CAPIMSG_LEN(skb->data));
1576 card->interface.rcvcallb_skb(card->myid, nccip->chan, skb);
1577 capi_cmsg_answer(cmsg);
1578 send_message(card, cmsg);
1579 }
1580
1581 static _cmsg s_cmsg;
1582
1583 static void capidrv_recv_message(struct capi20_appl *ap, struct sk_buff *skb)
1584 {
1585 if (capi_message2cmsg(&s_cmsg, skb->data)) {
1586 printk(KERN_ERR "capidrv: applid=%d: received invalid message\n",
1587 ap->applid);
1588 kfree_skb(skb);
1589 return;
1590 }
1591 if (debugmode > 3) {
1592 _cdebbuf *cdb = capi_cmsg2str(&s_cmsg);
1593
1594 if (cdb) {
1595 printk(KERN_DEBUG "%s: applid=%d %s\n", __func__,
1596 ap->applid, cdb->buf);
1597 cdebbuf_free(cdb);
1598 } else
1599 printk(KERN_DEBUG "%s: applid=%d %s not traced\n",
1600 __func__, ap->applid,
1601 capi_cmd2str(s_cmsg.Command, s_cmsg.Subcommand));
1602 }
1603 if (s_cmsg.Command == CAPI_DATA_B3
1604 && s_cmsg.Subcommand == CAPI_IND) {
1605 handle_data(&s_cmsg, skb);
1606 return;
1607 }
1608 if ((s_cmsg.adr.adrController & 0xffffff00) == 0)
1609 handle_controller(&s_cmsg);
1610 else if ((s_cmsg.adr.adrPLCI & 0xffff0000) == 0)
1611 handle_plci(&s_cmsg);
1612 else
1613 handle_ncci(&s_cmsg);
1614 /*
1615 * data of skb used in s_cmsg,
1616 * free data when s_cmsg is not used again
1617 * thanks to Lars Heete <hel@admin.de>
1618 */
1619 kfree_skb(skb);
1620 }
1621
1622 /* ------------------------------------------------------------------- */
1623
1624 #define PUTBYTE_TO_STATUS(card, byte) \
1625 do { \
1626 *(card)->q931_write++ = (byte); \
1627 if ((card)->q931_write > (card)->q931_end) \
1628 (card)->q931_write = (card)->q931_buf; \
1629 } while (0)
1630
1631 static void handle_dtrace_data(capidrv_contr *card,
1632 int send, int level2, u8 *data, u16 len)
1633 {
1634 u8 *p, *end;
1635 isdn_ctrl cmd;
1636
1637 if (!len) {
1638 printk(KERN_DEBUG "capidrv-%d: avmb1_q931_data: len == %d\n",
1639 card->contrnr, len);
1640 return;
1641 }
1642
1643 if (level2) {
1644 PUTBYTE_TO_STATUS(card, 'D');
1645 PUTBYTE_TO_STATUS(card, '2');
1646 PUTBYTE_TO_STATUS(card, send ? '>' : '<');
1647 PUTBYTE_TO_STATUS(card, ':');
1648 } else {
1649 PUTBYTE_TO_STATUS(card, 'D');
1650 PUTBYTE_TO_STATUS(card, '3');
1651 PUTBYTE_TO_STATUS(card, send ? '>' : '<');
1652 PUTBYTE_TO_STATUS(card, ':');
1653 }
1654
1655 for (p = data, end = data + len; p < end; p++) {
1656 PUTBYTE_TO_STATUS(card, ' ');
1657 PUTBYTE_TO_STATUS(card, hex_asc_hi(*p));
1658 PUTBYTE_TO_STATUS(card, hex_asc_lo(*p));
1659 }
1660 PUTBYTE_TO_STATUS(card, '\n');
1661
1662 cmd.command = ISDN_STAT_STAVAIL;
1663 cmd.driver = card->myid;
1664 cmd.arg = len * 3 + 5;
1665 card->interface.statcallb(&cmd);
1666 }
1667
1668 /* ------------------------------------------------------------------- */
1669
1670 static _cmsg cmdcmsg;
1671
1672 static int capidrv_ioctl(isdn_ctrl *c, capidrv_contr *card)
1673 {
1674 switch (c->arg) {
1675 case 1:
1676 debugmode = (int)(*((unsigned int *)c->parm.num));
1677 printk(KERN_DEBUG "capidrv-%d: debugmode=%d\n",
1678 card->contrnr, debugmode);
1679 return 0;
1680 default:
1681 printk(KERN_DEBUG "capidrv-%d: capidrv_ioctl(%ld) called ??\n",
1682 card->contrnr, c->arg);
1683 return -EINVAL;
1684 }
1685 return -EINVAL;
1686 }
1687
1688 /*
1689 * Handle leased lines (CAPI-Bundling)
1690 */
1691
1692 struct internal_bchannelinfo {
1693 unsigned short channelalloc;
1694 unsigned short operation;
1695 unsigned char cmask[31];
1696 };
1697
1698 static int decodeFVteln(char *teln, unsigned long *bmaskp, int *activep)
1699 {
1700 unsigned long bmask = 0;
1701 int active = !0;
1702 char *s;
1703 int i;
1704
1705 if (strncmp(teln, "FV:", 3) != 0)
1706 return 1;
1707 s = teln + 3;
1708 while (*s && *s == ' ') s++;
1709 if (!*s) return -2;
1710 if (*s == 'p' || *s == 'P') {
1711 active = 0;
1712 s++;
1713 }
1714 if (*s == 'a' || *s == 'A') {
1715 active = !0;
1716 s++;
1717 }
1718 while (*s) {
1719 int digit1 = 0;
1720 int digit2 = 0;
1721 char *endp;
1722
1723 digit1 = simple_strtoul(s, &endp, 10);
1724 if (s == endp)
1725 return -3;
1726 s = endp;
1727
1728 if (digit1 <= 0 || digit1 > 30) return -4;
1729 if (*s == 0 || *s == ',' || *s == ' ') {
1730 bmask |= (1 << digit1);
1731 digit1 = 0;
1732 if (*s) s++;
1733 continue;
1734 }
1735 if (*s != '-') return -5;
1736 s++;
1737
1738 digit2 = simple_strtoul(s, &endp, 10);
1739 if (s == endp)
1740 return -3;
1741 s = endp;
1742
1743 if (digit2 <= 0 || digit2 > 30) return -4;
1744 if (*s == 0 || *s == ',' || *s == ' ') {
1745 if (digit1 > digit2)
1746 for (i = digit2; i <= digit1; i++)
1747 bmask |= (1 << i);
1748 else
1749 for (i = digit1; i <= digit2; i++)
1750 bmask |= (1 << i);
1751 digit1 = digit2 = 0;
1752 if (*s) s++;
1753 continue;
1754 }
1755 return -6;
1756 }
1757 if (activep) *activep = active;
1758 if (bmaskp) *bmaskp = bmask;
1759 return 0;
1760 }
1761
1762 static int FVteln2capi20(char *teln, u8 AdditionalInfo[1 + 2 + 2 + 31])
1763 {
1764 unsigned long bmask;
1765 int active;
1766 int rc, i;
1767
1768 rc = decodeFVteln(teln, &bmask, &active);
1769 if (rc) return rc;
1770 /* Length */
1771 AdditionalInfo[0] = 2 + 2 + 31;
1772 /* Channel: 3 => use channel allocation */
1773 AdditionalInfo[1] = 3; AdditionalInfo[2] = 0;
1774 /* Operation: 0 => DTE mode, 1 => DCE mode */
1775 if (active) {
1776 AdditionalInfo[3] = 0; AdditionalInfo[4] = 0;
1777 } else {
1778 AdditionalInfo[3] = 1; AdditionalInfo[4] = 0;
1779 }
1780 /* Channel mask array */
1781 AdditionalInfo[5] = 0; /* no D-Channel */
1782 for (i = 1; i <= 30; i++)
1783 AdditionalInfo[5 + i] = (bmask & (1 << i)) ? 0xff : 0;
1784 return 0;
1785 }
1786
1787 static int capidrv_command(isdn_ctrl *c, capidrv_contr *card)
1788 {
1789 isdn_ctrl cmd;
1790 struct capidrv_bchan *bchan;
1791 struct capidrv_plci *plcip;
1792 u8 AdditionalInfo[1 + 2 + 2 + 31];
1793 int rc, isleasedline = 0;
1794
1795 if (c->command == ISDN_CMD_IOCTL)
1796 return capidrv_ioctl(c, card);
1797
1798 switch (c->command) {
1799 case ISDN_CMD_DIAL: {
1800 u8 calling[ISDN_MSNLEN + 3];
1801 u8 called[ISDN_MSNLEN + 2];
1802
1803 if (debugmode)
1804 printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_DIAL(ch=%ld,\"%s,%d,%d,%s\")\n",
1805 card->contrnr,
1806 c->arg,
1807 c->parm.setup.phone,
1808 c->parm.setup.si1,
1809 c->parm.setup.si2,
1810 c->parm.setup.eazmsn);
1811
1812 bchan = &card->bchans[c->arg % card->nbchan];
1813
1814 if (bchan->plcip) {
1815 printk(KERN_ERR "capidrv-%d: dail ch=%ld,\"%s,%d,%d,%s\" in use (plci=0x%x)\n",
1816 card->contrnr,
1817 c->arg,
1818 c->parm.setup.phone,
1819 c->parm.setup.si1,
1820 c->parm.setup.si2,
1821 c->parm.setup.eazmsn,
1822 bchan->plcip->plci);
1823 return 0;
1824 }
1825 bchan->si1 = c->parm.setup.si1;
1826 bchan->si2 = c->parm.setup.si2;
1827
1828 strncpy(bchan->num, c->parm.setup.phone, sizeof(bchan->num));
1829 strncpy(bchan->mynum, c->parm.setup.eazmsn, sizeof(bchan->mynum));
1830 rc = FVteln2capi20(bchan->num, AdditionalInfo);
1831 isleasedline = (rc == 0);
1832 if (rc < 0)
1833 printk(KERN_ERR "capidrv-%d: WARNING: invalid leased linedefinition \"%s\"\n", card->contrnr, bchan->num);
1834
1835 if (isleasedline) {
1836 calling[0] = 0;
1837 called[0] = 0;
1838 if (debugmode)
1839 printk(KERN_DEBUG "capidrv-%d: connecting leased line\n", card->contrnr);
1840 } else {
1841 calling[0] = strlen(bchan->mynum) + 2;
1842 calling[1] = 0;
1843 calling[2] = 0x80;
1844 strncpy(calling + 3, bchan->mynum, ISDN_MSNLEN);
1845 called[0] = strlen(bchan->num) + 1;
1846 called[1] = 0x80;
1847 strncpy(called + 2, bchan->num, ISDN_MSNLEN);
1848 }
1849
1850 capi_fill_CONNECT_REQ(&cmdcmsg,
1851 global.ap.applid,
1852 card->msgid++,
1853 card->contrnr, /* adr */
1854 si2cip(bchan->si1, bchan->si2), /* cipvalue */
1855 called, /* CalledPartyNumber */
1856 calling, /* CallingPartyNumber */
1857 NULL, /* CalledPartySubaddress */
1858 NULL, /* CallingPartySubaddress */
1859 b1prot(bchan->l2, bchan->l3), /* B1protocol */
1860 b2prot(bchan->l2, bchan->l3), /* B2protocol */
1861 b3prot(bchan->l2, bchan->l3), /* B3protocol */
1862 b1config(bchan->l2, bchan->l3), /* B1configuration */
1863 NULL, /* B2configuration */
1864 NULL, /* B3configuration */
1865 NULL, /* BC */
1866 NULL, /* LLC */
1867 NULL, /* HLC */
1868 /* BChannelinformation */
1869 isleasedline ? AdditionalInfo : NULL,
1870 NULL, /* Keypadfacility */
1871 NULL, /* Useruserdata */
1872 NULL /* Facilitydataarray */
1873 );
1874 if ((plcip = new_plci(card, (c->arg % card->nbchan))) == NULL) {
1875 cmd.command = ISDN_STAT_DHUP;
1876 cmd.driver = card->myid;
1877 cmd.arg = (c->arg % card->nbchan);
1878 card->interface.statcallb(&cmd);
1879 return -1;
1880 }
1881 plcip->msgid = cmdcmsg.Messagenumber;
1882 plcip->leasedline = isleasedline;
1883 plci_change_state(card, plcip, EV_PLCI_CONNECT_REQ);
1884 send_message(card, &cmdcmsg);
1885 return 0;
1886 }
1887
1888 case ISDN_CMD_ACCEPTD:
1889
1890 bchan = &card->bchans[c->arg % card->nbchan];
1891 if (debugmode)
1892 printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_ACCEPTD(ch=%ld) l2=%d l3=%d\n",
1893 card->contrnr,
1894 c->arg, bchan->l2, bchan->l3);
1895
1896 capi_fill_CONNECT_RESP(&cmdcmsg,
1897 global.ap.applid,
1898 card->msgid++,
1899 bchan->plcip->plci, /* adr */
1900 0, /* Reject */
1901 b1prot(bchan->l2, bchan->l3), /* B1protocol */
1902 b2prot(bchan->l2, bchan->l3), /* B2protocol */
1903 b3prot(bchan->l2, bchan->l3), /* B3protocol */
1904 b1config(bchan->l2, bchan->l3), /* B1configuration */
1905 NULL, /* B2configuration */
1906 NULL, /* B3configuration */
1907 NULL, /* ConnectedNumber */
1908 NULL, /* ConnectedSubaddress */
1909 NULL, /* LLC */
1910 NULL, /* BChannelinformation */
1911 NULL, /* Keypadfacility */
1912 NULL, /* Useruserdata */
1913 NULL /* Facilitydataarray */
1914 );
1915 if (capi_cmsg2message(&cmdcmsg, cmdcmsg.buf)) {
1916 printk(KERN_ERR "capidrv-%d: capidrv_command: parser failure\n",
1917 card->contrnr);
1918 return -EINVAL;
1919 }
1920 plci_change_state(card, bchan->plcip, EV_PLCI_CONNECT_RESP);
1921 send_message(card, &cmdcmsg);
1922 return 0;
1923
1924 case ISDN_CMD_ACCEPTB:
1925 if (debugmode)
1926 printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_ACCEPTB(ch=%ld)\n",
1927 card->contrnr,
1928 c->arg);
1929 return -ENOSYS;
1930
1931 case ISDN_CMD_HANGUP:
1932 if (debugmode)
1933 printk(KERN_DEBUG "capidrv-%d: ISDN_CMD_HANGUP(ch=%ld)\n",
1934 card->contrnr,
1935 c->arg);
1936 bchan = &card->bchans[c->arg % card->nbchan];
1937
1938 if (bchan->disconnecting) {
1939 if (debugmode)
1940 printk(KERN_DEBUG "capidrv-%d: chan %ld already disconnecting ...\n",
1941 card->contrnr,
1942 c->arg);
1943 return 0;
1944 }
1945 if (bchan->nccip) {
1946 bchan->disconnecting = 1;
1947 capi_fill_DISCONNECT_B3_REQ(&cmdcmsg,
1948 global.ap.applid,
1949 card->msgid++,
1950 bchan->nccip->ncci,
1951 NULL /* NCPI */
1952 );
1953 ncci_change_state(card, bchan->nccip, EV_NCCI_DISCONNECT_B3_REQ);
1954 send_message(card, &cmdcmsg);
1955 return 0;
1956 } else if (bchan->plcip) {
1957 if (bchan->plcip->state == ST_PLCI_INCOMING) {
1958 /*
1959 * just ignore, we a called from
1960 * isdn_status_callback(),
1961 * which will return 0 or 2, this is handled
1962 * by the CONNECT_IND handler
1963 */
1964 bchan->disconnecting = 1;
1965 return 0;
1966 } else if (bchan->plcip->plci) {
1967 bchan->disconnecting = 1;
1968 capi_fill_DISCONNECT_REQ(&cmdcmsg,
1969 global.ap.applid,
1970 card->msgid++,
1971 bchan->plcip->plci,
1972 NULL, /* BChannelinformation */
1973 NULL, /* Keypadfacility */
1974 NULL, /* Useruserdata */
1975 NULL /* Facilitydataarray */
1976 );
1977 plci_change_state(card, bchan->plcip, EV_PLCI_DISCONNECT_REQ);
1978 send_message(card, &cmdcmsg);
1979 return 0;
1980 } else {
1981 printk(KERN_ERR "capidrv-%d: chan %ld disconnect request while waiting for CONNECT_CONF\n",
1982 card->contrnr,
1983 c->arg);
1984 return -EINVAL;
1985 }
1986 }
1987 printk(KERN_ERR "capidrv-%d: chan %ld disconnect request on free channel\n",
1988 card->contrnr,
1989 c->arg);
1990 return -EINVAL;
1991 /* ready */
1992
1993 case ISDN_CMD_SETL2:
1994 if (debugmode)
1995 printk(KERN_DEBUG "capidrv-%d: set L2 on chan %ld to %ld\n",
1996 card->contrnr,
1997 (c->arg & 0xff), (c->arg >> 8));
1998 bchan = &card->bchans[(c->arg & 0xff) % card->nbchan];
1999 bchan->l2 = (c->arg >> 8);
2000 return 0;
2001
2002 case ISDN_CMD_SETL3:
2003 if (debugmode)
2004 printk(KERN_DEBUG "capidrv-%d: set L3 on chan %ld to %ld\n",
2005 card->contrnr,
2006 (c->arg & 0xff), (c->arg >> 8));
2007 bchan = &card->bchans[(c->arg & 0xff) % card->nbchan];
2008 bchan->l3 = (c->arg >> 8);
2009 return 0;
2010
2011 case ISDN_CMD_SETEAZ:
2012 if (debugmode)
2013 printk(KERN_DEBUG "capidrv-%d: set EAZ \"%s\" on chan %ld\n",
2014 card->contrnr,
2015 c->parm.num, c->arg);
2016 bchan = &card->bchans[c->arg % card->nbchan];
2017 strncpy(bchan->msn, c->parm.num, ISDN_MSNLEN);
2018 return 0;
2019
2020 case ISDN_CMD_CLREAZ:
2021 if (debugmode)
2022 printk(KERN_DEBUG "capidrv-%d: clearing EAZ on chan %ld\n",
2023 card->contrnr, c->arg);
2024 bchan = &card->bchans[c->arg % card->nbchan];
2025 bchan->msn[0] = 0;
2026 return 0;
2027
2028 default:
2029 printk(KERN_ERR "capidrv-%d: ISDN_CMD_%d, Huh?\n",
2030 card->contrnr, c->command);
2031 return -EINVAL;
2032 }
2033 return 0;
2034 }
2035
2036 static int if_command(isdn_ctrl *c)
2037 {
2038 capidrv_contr *card = findcontrbydriverid(c->driver);
2039
2040 if (card)
2041 return capidrv_command(c, card);
2042
2043 printk(KERN_ERR
2044 "capidrv: if_command %d called with invalid driverId %d!\n",
2045 c->command, c->driver);
2046 return -ENODEV;
2047 }
2048
2049 static _cmsg sendcmsg;
2050
2051 static int if_sendbuf(int id, int channel, int doack, struct sk_buff *skb)
2052 {
2053 capidrv_contr *card = findcontrbydriverid(id);
2054 capidrv_bchan *bchan;
2055 capidrv_ncci *nccip;
2056 int len = skb->len;
2057 int msglen;
2058 u16 errcode;
2059 u16 datahandle;
2060 u32 data;
2061
2062 if (!card) {
2063 printk(KERN_ERR "capidrv: if_sendbuf called with invalid driverId %d!\n",
2064 id);
2065 return 0;
2066 }
2067 if (debugmode > 4)
2068 printk(KERN_DEBUG "capidrv-%d: sendbuf len=%d skb=%p doack=%d\n",
2069 card->contrnr, len, skb, doack);
2070 bchan = &card->bchans[channel % card->nbchan];
2071 nccip = bchan->nccip;
2072 if (!nccip || nccip->state != ST_NCCI_ACTIVE) {
2073 printk(KERN_ERR "capidrv-%d: if_sendbuf: %s:%d: chan not up!\n",
2074 card->contrnr, card->name, channel);
2075 return 0;
2076 }
2077 datahandle = nccip->datahandle;
2078
2079 /*
2080 * Here we copy pointer skb->data into the 32-bit 'Data' field.
2081 * The 'Data' field is not used in practice in linux kernel
2082 * (neither in 32 or 64 bit), but should have some value,
2083 * since a CAPI message trace will display it.
2084 *
2085 * The correct value in the 32 bit case is the address of the
2086 * data, in 64 bit it makes no sense, we use 0 there.
2087 */
2088
2089 #ifdef CONFIG_64BIT
2090 data = 0;
2091 #else
2092 data = (unsigned long) skb->data;
2093 #endif
2094
2095 capi_fill_DATA_B3_REQ(&sendcmsg, global.ap.applid, card->msgid++,
2096 nccip->ncci, /* adr */
2097 data, /* Data */
2098 skb->len, /* DataLength */
2099 datahandle, /* DataHandle */
2100 0 /* Flags */
2101 );
2102
2103 if (capidrv_add_ack(nccip, datahandle, doack ? (int)skb->len : -1) < 0)
2104 return 0;
2105
2106 if (capi_cmsg2message(&sendcmsg, sendcmsg.buf)) {
2107 printk(KERN_ERR "capidrv-%d: if_sendbuf: parser failure\n",
2108 card->contrnr);
2109 return -EINVAL;
2110 }
2111 msglen = CAPIMSG_LEN(sendcmsg.buf);
2112 if (skb_headroom(skb) < msglen) {
2113 struct sk_buff *nskb = skb_realloc_headroom(skb, msglen);
2114 if (!nskb) {
2115 printk(KERN_ERR "capidrv-%d: if_sendbuf: no memory\n",
2116 card->contrnr);
2117 (void)capidrv_del_ack(nccip, datahandle);
2118 return 0;
2119 }
2120 printk(KERN_DEBUG "capidrv-%d: only %d bytes headroom, need %d\n",
2121 card->contrnr, skb_headroom(skb), msglen);
2122 memcpy(skb_push(nskb, msglen), sendcmsg.buf, msglen);
2123 errcode = capi20_put_message(&global.ap, nskb);
2124 if (errcode == CAPI_NOERROR) {
2125 dev_kfree_skb(skb);
2126 nccip->datahandle++;
2127 return len;
2128 }
2129 if (debugmode > 3)
2130 printk(KERN_DEBUG "capidrv-%d: sendbuf putmsg ret(%x) - %s\n",
2131 card->contrnr, errcode, capi_info2str(errcode));
2132 (void)capidrv_del_ack(nccip, datahandle);
2133 dev_kfree_skb(nskb);
2134 return errcode == CAPI_SENDQUEUEFULL ? 0 : -1;
2135 } else {
2136 memcpy(skb_push(skb, msglen), sendcmsg.buf, msglen);
2137 errcode = capi20_put_message(&global.ap, skb);
2138 if (errcode == CAPI_NOERROR) {
2139 nccip->datahandle++;
2140 return len;
2141 }
2142 if (debugmode > 3)
2143 printk(KERN_DEBUG "capidrv-%d: sendbuf putmsg ret(%x) - %s\n",
2144 card->contrnr, errcode, capi_info2str(errcode));
2145 skb_pull(skb, msglen);
2146 (void)capidrv_del_ack(nccip, datahandle);
2147 return errcode == CAPI_SENDQUEUEFULL ? 0 : -1;
2148 }
2149 }
2150
2151 static int if_readstat(u8 __user *buf, int len, int id, int channel)
2152 {
2153 capidrv_contr *card = findcontrbydriverid(id);
2154 int count;
2155 u8 __user *p;
2156
2157 if (!card) {
2158 printk(KERN_ERR "capidrv: if_readstat called with invalid driverId %d!\n",
2159 id);
2160 return -ENODEV;
2161 }
2162
2163 for (p = buf, count = 0; count < len; p++, count++) {
2164 if (put_user(*card->q931_read++, p))
2165 return -EFAULT;
2166 if (card->q931_read > card->q931_end)
2167 card->q931_read = card->q931_buf;
2168 }
2169 return count;
2170
2171 }
2172
2173 static void enable_dchannel_trace(capidrv_contr *card)
2174 {
2175 u8 manufacturer[CAPI_MANUFACTURER_LEN];
2176 capi_version version;
2177 u16 contr = card->contrnr;
2178 u16 errcode;
2179 u16 avmversion[3];
2180
2181 errcode = capi20_get_manufacturer(contr, manufacturer);
2182 if (errcode != CAPI_NOERROR) {
2183 printk(KERN_ERR "%s: can't get manufacturer (0x%x)\n",
2184 card->name, errcode);
2185 return;
2186 }
2187 if (strstr(manufacturer, "AVM") == NULL) {
2188 printk(KERN_ERR "%s: not from AVM, no d-channel trace possible (%s)\n",
2189 card->name, manufacturer);
2190 return;
2191 }
2192 errcode = capi20_get_version(contr, &version);
2193 if (errcode != CAPI_NOERROR) {
2194 printk(KERN_ERR "%s: can't get version (0x%x)\n",
2195 card->name, errcode);
2196 return;
2197 }
2198 avmversion[0] = (version.majormanuversion >> 4) & 0x0f;
2199 avmversion[1] = (version.majormanuversion << 4) & 0xf0;
2200 avmversion[1] |= (version.minormanuversion >> 4) & 0x0f;
2201 avmversion[2] |= version.minormanuversion & 0x0f;
2202
2203 if (avmversion[0] > 3 || (avmversion[0] == 3 && avmversion[1] > 5)) {
2204 printk(KERN_INFO "%s: D2 trace enabled\n", card->name);
2205 capi_fill_MANUFACTURER_REQ(&cmdcmsg, global.ap.applid,
2206 card->msgid++,
2207 contr,
2208 0x214D5641, /* ManuID */
2209 0, /* Class */
2210 1, /* Function */
2211 (_cstruct)"\004\200\014\000\000");
2212 } else {
2213 printk(KERN_INFO "%s: D3 trace enabled\n", card->name);
2214 capi_fill_MANUFACTURER_REQ(&cmdcmsg, global.ap.applid,
2215 card->msgid++,
2216 contr,
2217 0x214D5641, /* ManuID */
2218 0, /* Class */
2219 1, /* Function */
2220 (_cstruct)"\004\002\003\000\000");
2221 }
2222 send_message(card, &cmdcmsg);
2223 }
2224
2225
2226 static void send_listen(capidrv_contr *card)
2227 {
2228 capi_fill_LISTEN_REQ(&cmdcmsg, global.ap.applid,
2229 card->msgid++,
2230 card->contrnr, /* controller */
2231 1 << 6, /* Infomask */
2232 card->cipmask,
2233 card->cipmask2,
2234 NULL, NULL);
2235 listen_change_state(card, EV_LISTEN_REQ);
2236 send_message(card, &cmdcmsg);
2237 }
2238
2239 static void listentimerfunc(struct timer_list *t)
2240 {
2241 capidrv_contr *card = from_timer(card, t, listentimer);
2242 if (card->state != ST_LISTEN_NONE && card->state != ST_LISTEN_ACTIVE)
2243 printk(KERN_ERR "%s: controller dead ??\n", card->name);
2244 send_listen(card);
2245 mod_timer(&card->listentimer, jiffies + 60 * HZ);
2246 }
2247
2248
2249 static int capidrv_addcontr(u16 contr, struct capi_profile *profp)
2250 {
2251 capidrv_contr *card;
2252 unsigned long flags;
2253 isdn_ctrl cmd;
2254 char id[20];
2255 int i;
2256
2257 sprintf(id, "capidrv-%d", contr);
2258 if (!try_module_get(THIS_MODULE)) {
2259 printk(KERN_WARNING "capidrv: (%s) Could not reserve module\n", id);
2260 return -1;
2261 }
2262 if (!(card = kzalloc(sizeof(capidrv_contr), GFP_ATOMIC))) {
2263 printk(KERN_WARNING
2264 "capidrv: (%s) Could not allocate contr-struct.\n", id);
2265 return -1;
2266 }
2267 card->owner = THIS_MODULE;
2268 timer_setup(&card->listentimer, listentimerfunc, 0);
2269 strcpy(card->name, id);
2270 card->contrnr = contr;
2271 card->nbchan = profp->nbchannel;
2272 card->bchans = kmalloc_array(card->nbchan, sizeof(capidrv_bchan),
2273 GFP_ATOMIC);
2274 if (!card->bchans) {
2275 printk(KERN_WARNING
2276 "capidrv: (%s) Could not allocate bchan-structs.\n", id);
2277 module_put(card->owner);
2278 kfree(card);
2279 return -1;
2280 }
2281 card->interface.channels = profp->nbchannel;
2282 card->interface.maxbufsize = 2048;
2283 card->interface.command = if_command;
2284 card->interface.writebuf_skb = if_sendbuf;
2285 card->interface.writecmd = NULL;
2286 card->interface.readstat = if_readstat;
2287 card->interface.features =
2288 ISDN_FEATURE_L2_HDLC |
2289 ISDN_FEATURE_L2_TRANS |
2290 ISDN_FEATURE_L3_TRANS |
2291 ISDN_FEATURE_P_UNKNOWN |
2292 ISDN_FEATURE_L2_X75I |
2293 ISDN_FEATURE_L2_X75UI |
2294 ISDN_FEATURE_L2_X75BUI;
2295 if (profp->support1 & (1 << 2))
2296 card->interface.features |=
2297 ISDN_FEATURE_L2_V11096 |
2298 ISDN_FEATURE_L2_V11019 |
2299 ISDN_FEATURE_L2_V11038;
2300 if (profp->support1 & (1 << 8))
2301 card->interface.features |= ISDN_FEATURE_L2_MODEM;
2302 card->interface.hl_hdrlen = 22; /* len of DATA_B3_REQ */
2303 strncpy(card->interface.id, id, sizeof(card->interface.id) - 1);
2304
2305
2306 card->q931_read = card->q931_buf;
2307 card->q931_write = card->q931_buf;
2308 card->q931_end = card->q931_buf + sizeof(card->q931_buf) - 1;
2309
2310 if (!register_isdn(&card->interface)) {
2311 printk(KERN_ERR "capidrv: Unable to register contr %s\n", id);
2312 kfree(card->bchans);
2313 module_put(card->owner);
2314 kfree(card);
2315 return -1;
2316 }
2317 card->myid = card->interface.channels;
2318 memset(card->bchans, 0, sizeof(capidrv_bchan) * card->nbchan);
2319 for (i = 0; i < card->nbchan; i++) {
2320 card->bchans[i].contr = card;
2321 }
2322
2323 spin_lock_irqsave(&global_lock, flags);
2324 card->next = global.contr_list;
2325 global.contr_list = card;
2326 global.ncontr++;
2327 spin_unlock_irqrestore(&global_lock, flags);
2328
2329 cmd.command = ISDN_STAT_RUN;
2330 cmd.driver = card->myid;
2331 card->interface.statcallb(&cmd);
2332
2333 card->cipmask = 0x1FFF03FF; /* any */
2334 card->cipmask2 = 0;
2335
2336 send_listen(card);
2337 mod_timer(&card->listentimer, jiffies + 60 * HZ);
2338
2339 printk(KERN_INFO "%s: now up (%d B channels)\n",
2340 card->name, card->nbchan);
2341
2342 enable_dchannel_trace(card);
2343
2344 return 0;
2345 }
2346
2347 static int capidrv_delcontr(u16 contr)
2348 {
2349 capidrv_contr **pp, *card;
2350 unsigned long flags;
2351 isdn_ctrl cmd;
2352
2353 spin_lock_irqsave(&global_lock, flags);
2354 for (card = global.contr_list; card; card = card->next) {
2355 if (card->contrnr == contr)
2356 break;
2357 }
2358 if (!card) {
2359 spin_unlock_irqrestore(&global_lock, flags);
2360 printk(KERN_ERR "capidrv: delcontr: no contr %u\n", contr);
2361 return -1;
2362 }
2363
2364 /* FIXME: maybe a race condition the card should be removed
2365 * here from global list /kkeil
2366 */
2367 spin_unlock_irqrestore(&global_lock, flags);
2368
2369 del_timer(&card->listentimer);
2370
2371 if (debugmode)
2372 printk(KERN_DEBUG "capidrv-%d: id=%d unloading\n",
2373 card->contrnr, card->myid);
2374
2375 cmd.command = ISDN_STAT_STOP;
2376 cmd.driver = card->myid;
2377 card->interface.statcallb(&cmd);
2378
2379 while (card->nbchan) {
2380
2381 cmd.command = ISDN_STAT_DISCH;
2382 cmd.driver = card->myid;
2383 cmd.arg = card->nbchan - 1;
2384 cmd.parm.num[0] = 0;
2385 if (debugmode)
2386 printk(KERN_DEBUG "capidrv-%d: id=%d disable chan=%ld\n",
2387 card->contrnr, card->myid, cmd.arg);
2388 card->interface.statcallb(&cmd);
2389
2390 if (card->bchans[card->nbchan - 1].nccip)
2391 free_ncci(card, card->bchans[card->nbchan - 1].nccip);
2392 if (card->bchans[card->nbchan - 1].plcip)
2393 free_plci(card, card->bchans[card->nbchan - 1].plcip);
2394 if (card->plci_list)
2395 printk(KERN_ERR "capidrv: bug in free_plci()\n");
2396 card->nbchan--;
2397 }
2398 kfree(card->bchans);
2399 card->bchans = NULL;
2400
2401 if (debugmode)
2402 printk(KERN_DEBUG "capidrv-%d: id=%d isdn unload\n",
2403 card->contrnr, card->myid);
2404
2405 cmd.command = ISDN_STAT_UNLOAD;
2406 cmd.driver = card->myid;
2407 card->interface.statcallb(&cmd);
2408
2409 if (debugmode)
2410 printk(KERN_DEBUG "capidrv-%d: id=%d remove contr from list\n",
2411 card->contrnr, card->myid);
2412
2413 spin_lock_irqsave(&global_lock, flags);
2414 for (pp = &global.contr_list; *pp; pp = &(*pp)->next) {
2415 if (*pp == card) {
2416 *pp = (*pp)->next;
2417 card->next = NULL;
2418 global.ncontr--;
2419 break;
2420 }
2421 }
2422 spin_unlock_irqrestore(&global_lock, flags);
2423
2424 module_put(card->owner);
2425 printk(KERN_INFO "%s: now down.\n", card->name);
2426 kfree(card);
2427 return 0;
2428 }
2429
2430
2431 static int
2432 lower_callback(struct notifier_block *nb, unsigned long val, void *v)
2433 {
2434 capi_profile profile;
2435 u32 contr = (long)v;
2436
2437 switch (val) {
2438 case CAPICTR_UP:
2439 printk(KERN_INFO "capidrv: controller %hu up\n", contr);
2440 if (capi20_get_profile(contr, &profile) == CAPI_NOERROR)
2441 (void) capidrv_addcontr(contr, &profile);
2442 break;
2443 case CAPICTR_DOWN:
2444 printk(KERN_INFO "capidrv: controller %hu down\n", contr);
2445 (void) capidrv_delcontr(contr);
2446 break;
2447 }
2448 return NOTIFY_OK;
2449 }
2450
2451 /*
2452 * /proc/capi/capidrv:
2453 * nrecvctlpkt nrecvdatapkt nsendctlpkt nsenddatapkt
2454 */
2455 static int __maybe_unused capidrv_proc_show(struct seq_file *m, void *v)
2456 {
2457 seq_printf(m, "%lu %lu %lu %lu\n",
2458 global.ap.nrecvctlpkt,
2459 global.ap.nrecvdatapkt,
2460 global.ap.nsentctlpkt,
2461 global.ap.nsentdatapkt);
2462 return 0;
2463 }
2464
2465 static void __init proc_init(void)
2466 {
2467 proc_create_single("capi/capidrv", 0, NULL, capidrv_proc_show);
2468 }
2469
2470 static void __exit proc_exit(void)
2471 {
2472 remove_proc_entry("capi/capidrv", NULL);
2473 }
2474
2475 static struct notifier_block capictr_nb = {
2476 .notifier_call = lower_callback,
2477 };
2478
2479 static int __init capidrv_init(void)
2480 {
2481 capi_profile profile;
2482 u32 ncontr, contr;
2483 u16 errcode;
2484
2485 global.ap.rparam.level3cnt = -2; /* number of bchannels twice */
2486 global.ap.rparam.datablkcnt = 16;
2487 global.ap.rparam.datablklen = 2048;
2488
2489 global.ap.recv_message = capidrv_recv_message;
2490 errcode = capi20_register(&global.ap);
2491 if (errcode) {
2492 return -EIO;
2493 }
2494
2495 register_capictr_notifier(&capictr_nb);
2496
2497 errcode = capi20_get_profile(0, &profile);
2498 if (errcode != CAPI_NOERROR) {
2499 unregister_capictr_notifier(&capictr_nb);
2500 capi20_release(&global.ap);
2501 return -EIO;
2502 }
2503
2504 ncontr = profile.ncontroller;
2505 for (contr = 1; contr <= ncontr; contr++) {
2506 errcode = capi20_get_profile(contr, &profile);
2507 if (errcode != CAPI_NOERROR)
2508 continue;
2509 (void) capidrv_addcontr(contr, &profile);
2510 }
2511 proc_init();
2512
2513 return 0;
2514 }
2515
2516 static void __exit capidrv_exit(void)
2517 {
2518 unregister_capictr_notifier(&capictr_nb);
2519 capi20_release(&global.ap);
2520
2521 proc_exit();
2522 }
2523
2524 module_init(capidrv_init);
2525 module_exit(capidrv_exit);
Linux with added FPC-III support