1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19#include <linux/module.h>
20#include <linux/slab.h>
21#include <linux/init.h>
22#include "hisax.h"
23#include <linux/isdn/capicmd.h>
24
25const char *lli_revision = "$Revision: 2.59.2.4 $";
26
27extern struct IsdnCard cards[];
28
29static int init_b_st(struct Channel *chanp, int incoming);
30static void release_b_st(struct Channel *chanp);
31
32static struct Fsm callcfsm;
33static int chancount;
34
35
36#define ALERT_REJECT 0
37
38
39
40
41
42
43
44
45
46
47#define DEFAULT_B_DELAY 300
48
49
50
51#define FLG_START_B 0
52
53
54
55
56static inline struct IsdnCardState *
57hisax_findcard(int driverid)
58{
59 int i;
60
61 for (i = 0; i < nrcards; i++)
62 if (cards[i].cs)
63 if (cards[i].cs->myid == driverid)
64 return (cards[i].cs);
65 return (struct IsdnCardState *) 0;
66}
67
68static __printf(3, 4) void
69 link_debug(struct Channel *chanp, int direction, char *fmt, ...)
70{
71 va_list args;
72 char tmp[16];
73
74 va_start(args, fmt);
75 sprintf(tmp, "Ch%d %s ", chanp->chan,
76 direction ? "LL->HL" : "HL->LL");
77 VHiSax_putstatus(chanp->cs, tmp, fmt, args);
78 va_end(args);
79}
80
81enum {
82 ST_NULL,
83 ST_OUT_DIAL,
84 ST_IN_WAIT_LL,
85 ST_IN_ALERT_SENT,
86 ST_IN_WAIT_CONN_ACK,
87 ST_WAIT_BCONN,
88 ST_ACTIVE,
89 ST_WAIT_BRELEASE,
90 ST_WAIT_BREL_DISC,
91 ST_WAIT_DCOMMAND,
92 ST_WAIT_DRELEASE,
93 ST_WAIT_D_REL_CNF,
94 ST_IN_PROCEED_SEND,
95};
96
97
98#define STATE_COUNT (ST_IN_PROCEED_SEND + 1)
99
100static char *strState[] =
101{
102 "ST_NULL",
103 "ST_OUT_DIAL",
104 "ST_IN_WAIT_LL",
105 "ST_IN_ALERT_SENT",
106 "ST_IN_WAIT_CONN_ACK",
107 "ST_WAIT_BCONN",
108 "ST_ACTIVE",
109 "ST_WAIT_BRELEASE",
110 "ST_WAIT_BREL_DISC",
111 "ST_WAIT_DCOMMAND",
112 "ST_WAIT_DRELEASE",
113 "ST_WAIT_D_REL_CNF",
114 "ST_IN_PROCEED_SEND",
115};
116
117enum {
118 EV_DIAL,
119 EV_SETUP_CNF,
120 EV_ACCEPTB,
121 EV_DISCONNECT_IND,
122 EV_RELEASE,
123 EV_LEASED,
124 EV_LEASED_REL,
125 EV_SETUP_IND,
126 EV_ACCEPTD,
127 EV_SETUP_CMPL_IND,
128 EV_BC_EST,
129 EV_WRITEBUF,
130 EV_HANGUP,
131 EV_BC_REL,
132 EV_CINF,
133 EV_SUSPEND,
134 EV_RESUME,
135 EV_NOSETUP_RSP,
136 EV_SETUP_ERR,
137 EV_CONNECT_ERR,
138 EV_PROCEED,
139 EV_ALERT,
140 EV_REDIR,
141};
142
143#define EVENT_COUNT (EV_REDIR + 1)
144
145static char *strEvent[] =
146{
147 "EV_DIAL",
148 "EV_SETUP_CNF",
149 "EV_ACCEPTB",
150 "EV_DISCONNECT_IND",
151 "EV_RELEASE",
152 "EV_LEASED",
153 "EV_LEASED_REL",
154 "EV_SETUP_IND",
155 "EV_ACCEPTD",
156 "EV_SETUP_CMPL_IND",
157 "EV_BC_EST",
158 "EV_WRITEBUF",
159 "EV_HANGUP",
160 "EV_BC_REL",
161 "EV_CINF",
162 "EV_SUSPEND",
163 "EV_RESUME",
164 "EV_NOSETUP_RSP",
165 "EV_SETUP_ERR",
166 "EV_CONNECT_ERR",
167 "EV_PROCEED",
168 "EV_ALERT",
169 "EV_REDIR",
170};
171
172
173static inline void
174HL_LL(struct Channel *chanp, int command)
175{
176 isdn_ctrl ic;
177
178 ic.driver = chanp->cs->myid;
179 ic.command = command;
180 ic.arg = chanp->chan;
181 chanp->cs->iif.statcallb(&ic);
182}
183
184static inline void
185lli_deliver_cause(struct Channel *chanp)
186{
187 isdn_ctrl ic;
188
189 if (!chanp->proc)
190 return;
191 if (chanp->proc->para.cause == NO_CAUSE)
192 return;
193 ic.driver = chanp->cs->myid;
194 ic.command = ISDN_STAT_CAUSE;
195 ic.arg = chanp->chan;
196 if (chanp->cs->protocol == ISDN_PTYPE_EURO)
197 sprintf(ic.parm.num, "E%02X%02X", chanp->proc->para.loc & 0x7f,
198 chanp->proc->para.cause & 0x7f);
199 else
200 sprintf(ic.parm.num, "%02X%02X", chanp->proc->para.loc & 0x7f,
201 chanp->proc->para.cause & 0x7f);
202 chanp->cs->iif.statcallb(&ic);
203}
204
205static inline void
206lli_close(struct FsmInst *fi)
207{
208 struct Channel *chanp = fi->userdata;
209
210 FsmChangeState(fi, ST_NULL);
211 chanp->Flags = 0;
212 chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
213}
214
215static void
216lli_leased_in(struct FsmInst *fi, int event, void *arg)
217{
218 struct Channel *chanp = fi->userdata;
219 isdn_ctrl ic;
220 int ret;
221
222 if (!chanp->leased)
223 return;
224 chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
225 FsmChangeState(fi, ST_IN_WAIT_LL);
226 if (chanp->debug & 1)
227 link_debug(chanp, 0, "STAT_ICALL_LEASED");
228 ic.driver = chanp->cs->myid;
229 ic.command = ((chanp->chan < 2) ? ISDN_STAT_ICALL : ISDN_STAT_ICALLW);
230 ic.arg = chanp->chan;
231 ic.parm.setup.si1 = 7;
232 ic.parm.setup.si2 = 0;
233 ic.parm.setup.plan = 0;
234 ic.parm.setup.screen = 0;
235 sprintf(ic.parm.setup.eazmsn, "%d", chanp->chan + 1);
236 sprintf(ic.parm.setup.phone, "LEASED%d", chanp->cs->myid);
237 ret = chanp->cs->iif.statcallb(&ic);
238 if (chanp->debug & 1)
239 link_debug(chanp, 1, "statcallb ret=%d", ret);
240 if (!ret) {
241 chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
242 FsmChangeState(fi, ST_NULL);
243 }
244}
245
246
247
248
249
250static void
251lli_init_bchan_out(struct FsmInst *fi, int event, void *arg)
252{
253 struct Channel *chanp = fi->userdata;
254
255 FsmChangeState(fi, ST_WAIT_BCONN);
256 if (chanp->debug & 1)
257 link_debug(chanp, 0, "STAT_DCONN");
258 HL_LL(chanp, ISDN_STAT_DCONN);
259 init_b_st(chanp, 0);
260 chanp->b_st->lli.l4l3(chanp->b_st, DL_ESTABLISH | REQUEST, NULL);
261}
262
263static void
264lli_prep_dialout(struct FsmInst *fi, int event, void *arg)
265{
266 struct Channel *chanp = fi->userdata;
267
268 FsmDelTimer(&chanp->drel_timer, 60);
269 FsmDelTimer(&chanp->dial_timer, 73);
270 chanp->l2_active_protocol = chanp->l2_protocol;
271 chanp->incoming = 0;
272 chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
273 if (chanp->leased) {
274 lli_init_bchan_out(fi, event, arg);
275 } else {
276 FsmChangeState(fi, ST_OUT_DIAL);
277 chanp->d_st->lli.l4l3(chanp->d_st, CC_SETUP | REQUEST, chanp);
278 }
279}
280
281static void
282lli_resume(struct FsmInst *fi, int event, void *arg)
283{
284 struct Channel *chanp = fi->userdata;
285
286 FsmDelTimer(&chanp->drel_timer, 60);
287 FsmDelTimer(&chanp->dial_timer, 73);
288 chanp->l2_active_protocol = chanp->l2_protocol;
289 chanp->incoming = 0;
290 chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
291 if (chanp->leased) {
292 lli_init_bchan_out(fi, event, arg);
293 } else {
294 FsmChangeState(fi, ST_OUT_DIAL);
295 chanp->d_st->lli.l4l3(chanp->d_st, CC_RESUME | REQUEST, chanp);
296 }
297}
298
299static void
300lli_go_active(struct FsmInst *fi, int event, void *arg)
301{
302 struct Channel *chanp = fi->userdata;
303 isdn_ctrl ic;
304
305
306 FsmChangeState(fi, ST_ACTIVE);
307 chanp->data_open = !0;
308 if (chanp->bcs->conmsg)
309 strcpy(ic.parm.num, chanp->bcs->conmsg);
310 else
311 ic.parm.num[0] = 0;
312 if (chanp->debug & 1)
313 link_debug(chanp, 0, "STAT_BCONN %s", ic.parm.num);
314 ic.driver = chanp->cs->myid;
315 ic.command = ISDN_STAT_BCONN;
316 ic.arg = chanp->chan;
317 chanp->cs->iif.statcallb(&ic);
318 chanp->cs->cardmsg(chanp->cs, MDL_INFO_CONN, (void *) (long)chanp->chan);
319}
320
321
322
323
324
325
326
327
328static void
329lli_deliver_call(struct FsmInst *fi, int event, void *arg)
330{
331 struct Channel *chanp = fi->userdata;
332 isdn_ctrl ic;
333 int ret;
334
335 chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
336
337
338
339
340
341 if (1) {
342 FsmChangeState(fi, ST_IN_WAIT_LL);
343 if (chanp->debug & 1)
344 link_debug(chanp, 0, (chanp->chan < 2) ? "STAT_ICALL" : "STAT_ICALLW");
345 ic.driver = chanp->cs->myid;
346 ic.command = ((chanp->chan < 2) ? ISDN_STAT_ICALL : ISDN_STAT_ICALLW);
347
348 ic.arg = chanp->chan;
349
350
351
352
353 memcpy(&ic.parm.setup, &chanp->proc->para.setup, sizeof(setup_parm));
354 ret = chanp->cs->iif.statcallb(&ic);
355 if (chanp->debug & 1)
356 link_debug(chanp, 1, "statcallb ret=%d", ret);
357
358 switch (ret) {
359 case 1:
360 FsmDelTimer(&chanp->drel_timer, 61);
361 FsmChangeState(fi, ST_IN_ALERT_SENT);
362 chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
363 break;
364 case 5:
365 case 4:
366 FsmDelTimer(&chanp->drel_timer, 61);
367 FsmChangeState(fi, ST_IN_PROCEED_SEND);
368 chanp->d_st->lli.l4l3(chanp->d_st, CC_PROCEED_SEND | REQUEST, chanp->proc);
369 if (ret == 5) {
370 memcpy(&chanp->setup, &ic.parm.setup, sizeof(setup_parm));
371 chanp->d_st->lli.l4l3(chanp->d_st, CC_REDIR | REQUEST, chanp->proc);
372 }
373 break;
374 case 2:
375 break;
376 case 3:
377 FsmDelTimer(&chanp->drel_timer, 61);
378 chanp->d_st->lli.l4l3(chanp->d_st, CC_MORE_INFO | REQUEST, chanp->proc);
379 break;
380 case 0:
381 default:
382 chanp->d_st->lli.l4l3(chanp->d_st, CC_IGNORE | REQUEST, chanp->proc);
383 chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
384 FsmChangeState(fi, ST_NULL);
385 break;
386 }
387 } else {
388 chanp->d_st->lli.l4l3(chanp->d_st, CC_IGNORE | REQUEST, chanp->proc);
389 chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
390 }
391}
392
393static void
394lli_send_dconnect(struct FsmInst *fi, int event, void *arg)
395{
396 struct Channel *chanp = fi->userdata;
397
398 FsmChangeState(fi, ST_IN_WAIT_CONN_ACK);
399 chanp->d_st->lli.l4l3(chanp->d_st, CC_SETUP | RESPONSE, chanp->proc);
400}
401
402static void
403lli_send_alert(struct FsmInst *fi, int event, void *arg)
404{
405 struct Channel *chanp = fi->userdata;
406
407 FsmChangeState(fi, ST_IN_ALERT_SENT);
408 chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
409}
410
411static void
412lli_send_redir(struct FsmInst *fi, int event, void *arg)
413{
414 struct Channel *chanp = fi->userdata;
415
416 chanp->d_st->lli.l4l3(chanp->d_st, CC_REDIR | REQUEST, chanp->proc);
417}
418
419static void
420lli_init_bchan_in(struct FsmInst *fi, int event, void *arg)
421{
422 struct Channel *chanp = fi->userdata;
423
424 FsmChangeState(fi, ST_WAIT_BCONN);
425 if (chanp->debug & 1)
426 link_debug(chanp, 0, "STAT_DCONN");
427 HL_LL(chanp, ISDN_STAT_DCONN);
428 chanp->l2_active_protocol = chanp->l2_protocol;
429 chanp->incoming = !0;
430 init_b_st(chanp, !0);
431 chanp->b_st->lli.l4l3(chanp->b_st, DL_ESTABLISH | REQUEST, NULL);
432}
433
434static void
435lli_setup_rsp(struct FsmInst *fi, int event, void *arg)
436{
437 struct Channel *chanp = fi->userdata;
438
439 if (chanp->leased) {
440 lli_init_bchan_in(fi, event, arg);
441 } else {
442 FsmChangeState(fi, ST_IN_WAIT_CONN_ACK);
443#ifdef WANT_ALERT
444 chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
445#endif
446 chanp->d_st->lli.l4l3(chanp->d_st, CC_SETUP | RESPONSE, chanp->proc);
447 }
448}
449
450
451
452static void
453lli_suspend(struct FsmInst *fi, int event, void *arg)
454{
455 struct Channel *chanp = fi->userdata;
456
457 chanp->d_st->lli.l4l3(chanp->d_st, CC_SUSPEND | REQUEST, chanp->proc);
458}
459
460
461
462static void
463lli_leased_hup(struct FsmInst *fi, struct Channel *chanp)
464{
465 isdn_ctrl ic;
466
467 ic.driver = chanp->cs->myid;
468 ic.command = ISDN_STAT_CAUSE;
469 ic.arg = chanp->chan;
470 sprintf(ic.parm.num, "L0010");
471 chanp->cs->iif.statcallb(&ic);
472 if (chanp->debug & 1)
473 link_debug(chanp, 0, "STAT_DHUP");
474 HL_LL(chanp, ISDN_STAT_DHUP);
475 lli_close(fi);
476}
477
478static void
479lli_disconnect_req(struct FsmInst *fi, int event, void *arg)
480{
481 struct Channel *chanp = fi->userdata;
482
483 if (chanp->leased) {
484 lli_leased_hup(fi, chanp);
485 } else {
486 FsmChangeState(fi, ST_WAIT_DRELEASE);
487 if (chanp->proc)
488 chanp->proc->para.cause = 0x10;
489 chanp->d_st->lli.l4l3(chanp->d_st, CC_DISCONNECT | REQUEST,
490 chanp->proc);
491 }
492}
493
494static void
495lli_disconnect_reject(struct FsmInst *fi, int event, void *arg)
496{
497 struct Channel *chanp = fi->userdata;
498
499 if (chanp->leased) {
500 lli_leased_hup(fi, chanp);
501 } else {
502 FsmChangeState(fi, ST_WAIT_DRELEASE);
503 if (chanp->proc)
504 chanp->proc->para.cause = 0x15;
505 chanp->d_st->lli.l4l3(chanp->d_st, CC_DISCONNECT | REQUEST,
506 chanp->proc);
507 }
508}
509
510static void
511lli_dhup_close(struct FsmInst *fi, int event, void *arg)
512{
513 struct Channel *chanp = fi->userdata;
514
515 if (chanp->leased) {
516 lli_leased_hup(fi, chanp);
517 } else {
518 if (chanp->debug & 1)
519 link_debug(chanp, 0, "STAT_DHUP");
520 lli_deliver_cause(chanp);
521 HL_LL(chanp, ISDN_STAT_DHUP);
522 lli_close(fi);
523 }
524}
525
526static void
527lli_reject_req(struct FsmInst *fi, int event, void *arg)
528{
529 struct Channel *chanp = fi->userdata;
530
531 if (chanp->leased) {
532 lli_leased_hup(fi, chanp);
533 return;
534 }
535#ifndef ALERT_REJECT
536 if (chanp->proc)
537 chanp->proc->para.cause = 0x15;
538 chanp->d_st->lli.l4l3(chanp->d_st, CC_REJECT | REQUEST, chanp->proc);
539 lli_dhup_close(fi, event, arg);
540#else
541 FsmRestartTimer(&chanp->drel_timer, 40, EV_HANGUP, NULL, 63);
542 FsmChangeState(fi, ST_IN_ALERT_SENT);
543 chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
544#endif
545}
546
547static void
548lli_disconn_bchan(struct FsmInst *fi, int event, void *arg)
549{
550 struct Channel *chanp = fi->userdata;
551
552 chanp->data_open = 0;
553 FsmChangeState(fi, ST_WAIT_BRELEASE);
554 chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
555}
556
557static void
558lli_start_disc(struct FsmInst *fi, int event, void *arg)
559{
560 struct Channel *chanp = fi->userdata;
561
562 if (chanp->leased) {
563 lli_leased_hup(fi, chanp);
564 } else {
565 lli_disconnect_req(fi, event, arg);
566 }
567}
568
569static void
570lli_rel_b_disc(struct FsmInst *fi, int event, void *arg)
571{
572 struct Channel *chanp = fi->userdata;
573
574 release_b_st(chanp);
575 lli_start_disc(fi, event, arg);
576}
577
578static void
579lli_bhup_disc(struct FsmInst *fi, int event, void *arg)
580{
581 struct Channel *chanp = fi->userdata;
582
583 if (chanp->debug & 1)
584 link_debug(chanp, 0, "STAT_BHUP");
585 HL_LL(chanp, ISDN_STAT_BHUP);
586 lli_rel_b_disc(fi, event, arg);
587}
588
589static void
590lli_bhup_rel_b(struct FsmInst *fi, int event, void *arg)
591{
592 struct Channel *chanp = fi->userdata;
593
594 FsmChangeState(fi, ST_WAIT_DCOMMAND);
595 chanp->data_open = 0;
596 if (chanp->debug & 1)
597 link_debug(chanp, 0, "STAT_BHUP");
598 HL_LL(chanp, ISDN_STAT_BHUP);
599 release_b_st(chanp);
600}
601
602static void
603lli_release_bchan(struct FsmInst *fi, int event, void *arg)
604{
605 struct Channel *chanp = fi->userdata;
606
607 chanp->data_open = 0;
608 FsmChangeState(fi, ST_WAIT_BREL_DISC);
609 chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
610}
611
612
613static void
614lli_rel_b_dhup(struct FsmInst *fi, int event, void *arg)
615{
616 struct Channel *chanp = fi->userdata;
617
618 release_b_st(chanp);
619 lli_dhup_close(fi, event, arg);
620}
621
622static void
623lli_bhup_dhup(struct FsmInst *fi, int event, void *arg)
624{
625 struct Channel *chanp = fi->userdata;
626
627 if (chanp->debug & 1)
628 link_debug(chanp, 0, "STAT_BHUP");
629 HL_LL(chanp, ISDN_STAT_BHUP);
630 lli_rel_b_dhup(fi, event, arg);
631}
632
633static void
634lli_abort(struct FsmInst *fi, int event, void *arg)
635{
636 struct Channel *chanp = fi->userdata;
637
638 chanp->data_open = 0;
639 chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
640 lli_bhup_dhup(fi, event, arg);
641}
642
643static void
644lli_release_req(struct FsmInst *fi, int event, void *arg)
645{
646 struct Channel *chanp = fi->userdata;
647
648 if (chanp->leased) {
649 lli_leased_hup(fi, chanp);
650 } else {
651 FsmChangeState(fi, ST_WAIT_D_REL_CNF);
652 chanp->d_st->lli.l4l3(chanp->d_st, CC_RELEASE | REQUEST,
653 chanp->proc);
654 }
655}
656
657static void
658lli_rel_b_release_req(struct FsmInst *fi, int event, void *arg)
659{
660 struct Channel *chanp = fi->userdata;
661
662 release_b_st(chanp);
663 lli_release_req(fi, event, arg);
664}
665
666static void
667lli_bhup_release_req(struct FsmInst *fi, int event, void *arg)
668{
669 struct Channel *chanp = fi->userdata;
670
671 if (chanp->debug & 1)
672 link_debug(chanp, 0, "STAT_BHUP");
673 HL_LL(chanp, ISDN_STAT_BHUP);
674 lli_rel_b_release_req(fi, event, arg);
675}
676
677
678
679static void
680lli_charge_info(struct FsmInst *fi, int event, void *arg)
681{
682 struct Channel *chanp = fi->userdata;
683 isdn_ctrl ic;
684
685 ic.driver = chanp->cs->myid;
686 ic.command = ISDN_STAT_CINF;
687 ic.arg = chanp->chan;
688 sprintf(ic.parm.num, "%d", chanp->proc->para.chargeinfo);
689 chanp->cs->iif.statcallb(&ic);
690}
691
692
693
694static void
695lli_dchan_not_ready(struct FsmInst *fi, int event, void *arg)
696{
697 struct Channel *chanp = fi->userdata;
698
699 if (chanp->debug & 1)
700 link_debug(chanp, 0, "STAT_DHUP");
701 HL_LL(chanp, ISDN_STAT_DHUP);
702}
703
704static void
705lli_no_setup_rsp(struct FsmInst *fi, int event, void *arg)
706{
707 struct Channel *chanp = fi->userdata;
708
709 if (chanp->debug & 1)
710 link_debug(chanp, 0, "STAT_DHUP");
711 HL_LL(chanp, ISDN_STAT_DHUP);
712 lli_close(fi);
713}
714
715static void
716lli_error(struct FsmInst *fi, int event, void *arg)
717{
718 FsmChangeState(fi, ST_WAIT_DRELEASE);
719}
720
721static void
722lli_failure_l(struct FsmInst *fi, int event, void *arg)
723{
724 struct Channel *chanp = fi->userdata;
725 isdn_ctrl ic;
726
727 FsmChangeState(fi, ST_NULL);
728 ic.driver = chanp->cs->myid;
729 ic.command = ISDN_STAT_CAUSE;
730 ic.arg = chanp->chan;
731 sprintf(ic.parm.num, "L%02X%02X", 0, 0x2f);
732 chanp->cs->iif.statcallb(&ic);
733 HL_LL(chanp, ISDN_STAT_DHUP);
734 chanp->Flags = 0;
735 chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
736}
737
738static void
739lli_rel_b_fail(struct FsmInst *fi, int event, void *arg)
740{
741 struct Channel *chanp = fi->userdata;
742
743 release_b_st(chanp);
744 lli_failure_l(fi, event, arg);
745}
746
747static void
748lli_bhup_fail(struct FsmInst *fi, int event, void *arg)
749{
750 struct Channel *chanp = fi->userdata;
751
752 if (chanp->debug & 1)
753 link_debug(chanp, 0, "STAT_BHUP");
754 HL_LL(chanp, ISDN_STAT_BHUP);
755 lli_rel_b_fail(fi, event, arg);
756}
757
758static void
759lli_failure_a(struct FsmInst *fi, int event, void *arg)
760{
761 struct Channel *chanp = fi->userdata;
762
763 chanp->data_open = 0;
764 chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
765 lli_bhup_fail(fi, event, arg);
766}
767
768
769static struct FsmNode fnlist[] __initdata =
770{
771 {ST_NULL, EV_DIAL, lli_prep_dialout},
772 {ST_NULL, EV_RESUME, lli_resume},
773 {ST_NULL, EV_SETUP_IND, lli_deliver_call},
774 {ST_NULL, EV_LEASED, lli_leased_in},
775 {ST_OUT_DIAL, EV_SETUP_CNF, lli_init_bchan_out},
776 {ST_OUT_DIAL, EV_HANGUP, lli_disconnect_req},
777 {ST_OUT_DIAL, EV_DISCONNECT_IND, lli_release_req},
778 {ST_OUT_DIAL, EV_RELEASE, lli_dhup_close},
779 {ST_OUT_DIAL, EV_NOSETUP_RSP, lli_no_setup_rsp},
780 {ST_OUT_DIAL, EV_SETUP_ERR, lli_error},
781 {ST_IN_WAIT_LL, EV_LEASED_REL, lli_failure_l},
782 {ST_IN_WAIT_LL, EV_ACCEPTD, lli_setup_rsp},
783 {ST_IN_WAIT_LL, EV_HANGUP, lli_reject_req},
784 {ST_IN_WAIT_LL, EV_DISCONNECT_IND, lli_release_req},
785 {ST_IN_WAIT_LL, EV_RELEASE, lli_dhup_close},
786 {ST_IN_WAIT_LL, EV_SETUP_IND, lli_deliver_call},
787 {ST_IN_WAIT_LL, EV_SETUP_ERR, lli_error},
788 {ST_IN_ALERT_SENT, EV_SETUP_CMPL_IND, lli_init_bchan_in},
789 {ST_IN_ALERT_SENT, EV_ACCEPTD, lli_send_dconnect},
790 {ST_IN_ALERT_SENT, EV_HANGUP, lli_disconnect_reject},
791 {ST_IN_ALERT_SENT, EV_DISCONNECT_IND, lli_release_req},
792 {ST_IN_ALERT_SENT, EV_RELEASE, lli_dhup_close},
793 {ST_IN_ALERT_SENT, EV_REDIR, lli_send_redir},
794 {ST_IN_PROCEED_SEND, EV_REDIR, lli_send_redir},
795 {ST_IN_PROCEED_SEND, EV_ALERT, lli_send_alert},
796 {ST_IN_PROCEED_SEND, EV_ACCEPTD, lli_send_dconnect},
797 {ST_IN_PROCEED_SEND, EV_HANGUP, lli_disconnect_reject},
798 {ST_IN_PROCEED_SEND, EV_DISCONNECT_IND, lli_dhup_close},
799 {ST_IN_ALERT_SENT, EV_RELEASE, lli_dhup_close},
800 {ST_IN_WAIT_CONN_ACK, EV_SETUP_CMPL_IND, lli_init_bchan_in},
801 {ST_IN_WAIT_CONN_ACK, EV_HANGUP, lli_disconnect_req},
802 {ST_IN_WAIT_CONN_ACK, EV_DISCONNECT_IND, lli_release_req},
803 {ST_IN_WAIT_CONN_ACK, EV_RELEASE, lli_dhup_close},
804 {ST_IN_WAIT_CONN_ACK, EV_CONNECT_ERR, lli_error},
805 {ST_WAIT_BCONN, EV_BC_EST, lli_go_active},
806 {ST_WAIT_BCONN, EV_BC_REL, lli_rel_b_disc},
807 {ST_WAIT_BCONN, EV_HANGUP, lli_rel_b_disc},
808 {ST_WAIT_BCONN, EV_DISCONNECT_IND, lli_rel_b_release_req},
809 {ST_WAIT_BCONN, EV_RELEASE, lli_rel_b_dhup},
810 {ST_WAIT_BCONN, EV_LEASED_REL, lli_rel_b_fail},
811 {ST_WAIT_BCONN, EV_CINF, lli_charge_info},
812 {ST_ACTIVE, EV_CINF, lli_charge_info},
813 {ST_ACTIVE, EV_BC_REL, lli_bhup_rel_b},
814 {ST_ACTIVE, EV_SUSPEND, lli_suspend},
815 {ST_ACTIVE, EV_HANGUP, lli_disconn_bchan},
816 {ST_ACTIVE, EV_DISCONNECT_IND, lli_release_bchan},
817 {ST_ACTIVE, EV_RELEASE, lli_abort},
818 {ST_ACTIVE, EV_LEASED_REL, lli_failure_a},
819 {ST_WAIT_BRELEASE, EV_BC_REL, lli_bhup_disc},
820 {ST_WAIT_BRELEASE, EV_DISCONNECT_IND, lli_bhup_release_req},
821 {ST_WAIT_BRELEASE, EV_RELEASE, lli_bhup_dhup},
822 {ST_WAIT_BRELEASE, EV_LEASED_REL, lli_bhup_fail},
823 {ST_WAIT_BREL_DISC, EV_BC_REL, lli_bhup_release_req},
824 {ST_WAIT_BREL_DISC, EV_RELEASE, lli_bhup_dhup},
825 {ST_WAIT_DCOMMAND, EV_HANGUP, lli_start_disc},
826 {ST_WAIT_DCOMMAND, EV_DISCONNECT_IND, lli_release_req},
827 {ST_WAIT_DCOMMAND, EV_RELEASE, lli_dhup_close},
828 {ST_WAIT_DCOMMAND, EV_LEASED_REL, lli_failure_l},
829 {ST_WAIT_DRELEASE, EV_RELEASE, lli_dhup_close},
830 {ST_WAIT_DRELEASE, EV_DIAL, lli_dchan_not_ready},
831
832 {ST_WAIT_D_REL_CNF, EV_RELEASE, lli_dhup_close},
833 {ST_WAIT_D_REL_CNF, EV_DIAL, lli_dchan_not_ready},
834};
835
836
837int __init
838CallcNew(void)
839{
840 callcfsm.state_count = STATE_COUNT;
841 callcfsm.event_count = EVENT_COUNT;
842 callcfsm.strEvent = strEvent;
843 callcfsm.strState = strState;
844 return FsmNew(&callcfsm, fnlist, ARRAY_SIZE(fnlist));
845}
846
847void
848CallcFree(void)
849{
850 FsmFree(&callcfsm);
851}
852
853static void
854release_b_st(struct Channel *chanp)
855{
856 struct PStack *st = chanp->b_st;
857
858 if (test_and_clear_bit(FLG_START_B, &chanp->Flags)) {
859 chanp->bcs->BC_Close(chanp->bcs);
860 switch (chanp->l2_active_protocol) {
861 case (ISDN_PROTO_L2_X75I):
862 releasestack_isdnl2(st);
863 break;
864 case (ISDN_PROTO_L2_HDLC):
865 case (ISDN_PROTO_L2_HDLC_56K):
866 case (ISDN_PROTO_L2_TRANS):
867 case (ISDN_PROTO_L2_MODEM):
868 case (ISDN_PROTO_L2_FAX):
869 releasestack_transl2(st);
870 break;
871 }
872 }
873}
874
875static struct Channel
876*selectfreechannel(struct PStack *st, int bch)
877{
878 struct IsdnCardState *cs = st->l1.hardware;
879 struct Channel *chanp = st->lli.userdata;
880 int i;
881
882 if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
883 i = 1;
884 else
885 i = 0;
886
887 if (!bch) {
888 i = 2;
889 chanp += 2;
890 }
891
892 while (i < ((bch) ? cs->chanlimit : (2 + MAX_WAITING_CALLS))) {
893 if (chanp->fi.state == ST_NULL)
894 return (chanp);
895 chanp++;
896 i++;
897 }
898
899 if (bch) {
900 i = 2;
901 chanp = st->lli.userdata;
902 chanp += i;
903 while (i < (2 + MAX_WAITING_CALLS)) {
904 if (chanp->fi.state == ST_NULL)
905 return (chanp);
906 chanp++;
907 i++;
908 }
909 }
910 return (NULL);
911}
912
913static void stat_redir_result(struct IsdnCardState *cs, int chan, ulong result)
914{ isdn_ctrl ic;
915
916 ic.driver = cs->myid;
917 ic.command = ISDN_STAT_REDIR;
918 ic.arg = chan;
919 ic.parm.num[0] = result;
920 cs->iif.statcallb(&ic);
921}
922
923static void
924dchan_l3l4(struct PStack *st, int pr, void *arg)
925{
926 struct l3_process *pc = arg;
927 struct IsdnCardState *cs = st->l1.hardware;
928 struct Channel *chanp;
929
930 if (!pc)
931 return;
932
933 if (pr == (CC_SETUP | INDICATION)) {
934 if (!(chanp = selectfreechannel(pc->st, pc->para.bchannel))) {
935 pc->para.cause = 0x11;
936 pc->st->lli.l4l3(pc->st, CC_REJECT | REQUEST, pc);
937 } else {
938 chanp->proc = pc;
939 pc->chan = chanp;
940 FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
941 }
942 return;
943 }
944 if (!(chanp = pc->chan))
945 return;
946
947 switch (pr) {
948 case (CC_MORE_INFO | INDICATION):
949 FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
950 break;
951 case (CC_DISCONNECT | INDICATION):
952 FsmEvent(&chanp->fi, EV_DISCONNECT_IND, NULL);
953 break;
954 case (CC_RELEASE | CONFIRM):
955 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
956 break;
957 case (CC_SUSPEND | CONFIRM):
958 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
959 break;
960 case (CC_RESUME | CONFIRM):
961 FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
962 break;
963 case (CC_RESUME_ERR):
964 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
965 break;
966 case (CC_RELEASE | INDICATION):
967 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
968 break;
969 case (CC_SETUP_COMPL | INDICATION):
970 FsmEvent(&chanp->fi, EV_SETUP_CMPL_IND, NULL);
971 break;
972 case (CC_SETUP | CONFIRM):
973 FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
974 break;
975 case (CC_CHARGE | INDICATION):
976 FsmEvent(&chanp->fi, EV_CINF, NULL);
977 break;
978 case (CC_NOSETUP_RSP):
979 FsmEvent(&chanp->fi, EV_NOSETUP_RSP, NULL);
980 break;
981 case (CC_SETUP_ERR):
982 FsmEvent(&chanp->fi, EV_SETUP_ERR, NULL);
983 break;
984 case (CC_CONNECT_ERR):
985 FsmEvent(&chanp->fi, EV_CONNECT_ERR, NULL);
986 break;
987 case (CC_RELEASE_ERR):
988 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
989 break;
990 case (CC_PROCEED_SEND | INDICATION):
991 case (CC_PROCEEDING | INDICATION):
992 case (CC_ALERTING | INDICATION):
993 case (CC_PROGRESS | INDICATION):
994 case (CC_NOTIFY | INDICATION):
995 break;
996 case (CC_REDIR | INDICATION):
997 stat_redir_result(cs, chanp->chan, pc->redir_result);
998 break;
999 default:
1000 if (chanp->debug & 0x800) {
1001 HiSax_putstatus(chanp->cs, "Ch",
1002 "%d L3->L4 unknown primitiv %#x",
1003 chanp->chan, pr);
1004 }
1005 }
1006}
1007
1008static void
1009dummy_pstack(struct PStack *st, int pr, void *arg) {
1010 printk(KERN_WARNING"call to dummy_pstack pr=%04x arg %lx\n", pr, (long)arg);
1011}
1012
1013static int
1014init_PStack(struct PStack **stp) {
1015 *stp = kmalloc(sizeof(struct PStack), GFP_KERNEL);
1016 if (!*stp)
1017 return -ENOMEM;
1018 (*stp)->next = NULL;
1019 (*stp)->l1.l1l2 = dummy_pstack;
1020 (*stp)->l1.l1hw = dummy_pstack;
1021 (*stp)->l1.l1tei = dummy_pstack;
1022 (*stp)->l2.l2tei = dummy_pstack;
1023 (*stp)->l2.l2l1 = dummy_pstack;
1024 (*stp)->l2.l2l3 = dummy_pstack;
1025 (*stp)->l3.l3l2 = dummy_pstack;
1026 (*stp)->l3.l3ml3 = dummy_pstack;
1027 (*stp)->l3.l3l4 = dummy_pstack;
1028 (*stp)->lli.l4l3 = dummy_pstack;
1029 (*stp)->ma.layer = dummy_pstack;
1030 return 0;
1031}
1032
1033static int
1034init_d_st(struct Channel *chanp)
1035{
1036 struct PStack *st;
1037 struct IsdnCardState *cs = chanp->cs;
1038 char tmp[16];
1039 int err;
1040
1041 err = init_PStack(&chanp->d_st);
1042 if (err)
1043 return err;
1044 st = chanp->d_st;
1045 st->next = NULL;
1046 HiSax_addlist(cs, st);
1047 setstack_HiSax(st, cs);
1048 st->l2.sap = 0;
1049 st->l2.tei = -1;
1050 st->l2.flag = 0;
1051 test_and_set_bit(FLG_MOD128, &st->l2.flag);
1052 test_and_set_bit(FLG_LAPD, &st->l2.flag);
1053 test_and_set_bit(FLG_ORIG, &st->l2.flag);
1054 st->l2.maxlen = MAX_DFRAME_LEN;
1055 st->l2.window = 1;
1056 st->l2.T200 = 1000;
1057 st->l2.N200 = 3;
1058 st->l2.T203 = 10000;
1059 if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
1060 sprintf(tmp, "DCh%d Q.921 ", chanp->chan);
1061 else
1062 sprintf(tmp, "DCh Q.921 ");
1063 setstack_isdnl2(st, tmp);
1064 setstack_l3dc(st, chanp);
1065 st->lli.userdata = chanp;
1066 st->l3.l3l4 = dchan_l3l4;
1067
1068 return 0;
1069}
1070
1071static __printf(2, 3) void
1072 callc_debug(struct FsmInst *fi, char *fmt, ...)
1073{
1074 va_list args;
1075 struct Channel *chanp = fi->userdata;
1076 char tmp[16];
1077
1078 va_start(args, fmt);
1079 sprintf(tmp, "Ch%d callc ", chanp->chan);
1080 VHiSax_putstatus(chanp->cs, tmp, fmt, args);
1081 va_end(args);
1082}
1083
1084static int
1085init_chan(int chan, struct IsdnCardState *csta)
1086{
1087 struct Channel *chanp = csta->channel + chan;
1088 int err;
1089
1090 chanp->cs = csta;
1091 chanp->bcs = csta->bcs + chan;
1092 chanp->chan = chan;
1093 chanp->incoming = 0;
1094 chanp->debug = 0;
1095 chanp->Flags = 0;
1096 chanp->leased = 0;
1097 err = init_PStack(&chanp->b_st);
1098 if (err)
1099 return err;
1100 chanp->b_st->l1.delay = DEFAULT_B_DELAY;
1101 chanp->fi.fsm = &callcfsm;
1102 chanp->fi.state = ST_NULL;
1103 chanp->fi.debug = 0;
1104 chanp->fi.userdata = chanp;
1105 chanp->fi.printdebug = callc_debug;
1106 FsmInitTimer(&chanp->fi, &chanp->dial_timer);
1107 FsmInitTimer(&chanp->fi, &chanp->drel_timer);
1108 if (!chan || (test_bit(FLG_TWO_DCHAN, &csta->HW_Flags) && chan < 2)) {
1109 err = init_d_st(chanp);
1110 if (err)
1111 return err;
1112 } else {
1113 chanp->d_st = csta->channel->d_st;
1114 }
1115 chanp->data_open = 0;
1116 return 0;
1117}
1118
1119int
1120CallcNewChan(struct IsdnCardState *csta) {
1121 int i, err;
1122
1123 chancount += 2;
1124 err = init_chan(0, csta);
1125 if (err)
1126 return err;
1127 err = init_chan(1, csta);
1128 if (err)
1129 return err;
1130 printk(KERN_INFO "HiSax: 2 channels added\n");
1131
1132 for (i = 0; i < MAX_WAITING_CALLS; i++) {
1133 err = init_chan(i + 2, csta);
1134 if (err)
1135 return err;
1136 }
1137 printk(KERN_INFO "HiSax: MAX_WAITING_CALLS added\n");
1138 if (test_bit(FLG_PTP, &csta->channel->d_st->l2.flag)) {
1139 printk(KERN_INFO "LAYER2 WATCHING ESTABLISH\n");
1140 csta->channel->d_st->lli.l4l3(csta->channel->d_st,
1141 DL_ESTABLISH | REQUEST, NULL);
1142 }
1143 return (0);
1144}
1145
1146static void
1147release_d_st(struct Channel *chanp)
1148{
1149 struct PStack *st = chanp->d_st;
1150
1151 if (!st)
1152 return;
1153 releasestack_isdnl2(st);
1154 releasestack_isdnl3(st);
1155 HiSax_rmlist(st->l1.hardware, st);
1156 kfree(st);
1157 chanp->d_st = NULL;
1158}
1159
1160void
1161CallcFreeChan(struct IsdnCardState *csta)
1162{
1163 int i;
1164
1165 for (i = 0; i < 2; i++) {
1166 FsmDelTimer(&csta->channel[i].drel_timer, 74);
1167 FsmDelTimer(&csta->channel[i].dial_timer, 75);
1168 if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags))
1169 release_d_st(csta->channel + i);
1170 if (csta->channel[i].b_st) {
1171 release_b_st(csta->channel + i);
1172 kfree(csta->channel[i].b_st);
1173 csta->channel[i].b_st = NULL;
1174 } else
1175 printk(KERN_WARNING "CallcFreeChan b_st ch%d already freed\n", i);
1176 if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
1177 release_d_st(csta->channel + i);
1178 } else
1179 csta->channel[i].d_st = NULL;
1180 }
1181}
1182
1183static void
1184lldata_handler(struct PStack *st, int pr, void *arg)
1185{
1186 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1187 struct sk_buff *skb = arg;
1188
1189 switch (pr) {
1190 case (DL_DATA | INDICATION):
1191 if (chanp->data_open) {
1192 if (chanp->debug & 0x800)
1193 link_debug(chanp, 0, "lldata: %d", skb->len);
1194 chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
1195 } else {
1196 link_debug(chanp, 0, "lldata: channel not open");
1197 dev_kfree_skb(skb);
1198 }
1199 break;
1200 case (DL_ESTABLISH | INDICATION):
1201 case (DL_ESTABLISH | CONFIRM):
1202 FsmEvent(&chanp->fi, EV_BC_EST, NULL);
1203 break;
1204 case (DL_RELEASE | INDICATION):
1205 case (DL_RELEASE | CONFIRM):
1206 FsmEvent(&chanp->fi, EV_BC_REL, NULL);
1207 break;
1208 default:
1209 printk(KERN_WARNING "lldata_handler unknown primitive %#x\n",
1210 pr);
1211 break;
1212 }
1213}
1214
1215static void
1216lltrans_handler(struct PStack *st, int pr, void *arg)
1217{
1218 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1219 struct sk_buff *skb = arg;
1220
1221 switch (pr) {
1222 case (PH_DATA | INDICATION):
1223 if (chanp->data_open) {
1224 if (chanp->debug & 0x800)
1225 link_debug(chanp, 0, "lltrans: %d", skb->len);
1226 chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
1227 } else {
1228 link_debug(chanp, 0, "lltrans: channel not open");
1229 dev_kfree_skb(skb);
1230 }
1231 break;
1232 case (PH_ACTIVATE | INDICATION):
1233 case (PH_ACTIVATE | CONFIRM):
1234 FsmEvent(&chanp->fi, EV_BC_EST, NULL);
1235 break;
1236 case (PH_DEACTIVATE | INDICATION):
1237 case (PH_DEACTIVATE | CONFIRM):
1238 FsmEvent(&chanp->fi, EV_BC_REL, NULL);
1239 break;
1240 default:
1241 printk(KERN_WARNING "lltrans_handler unknown primitive %#x\n",
1242 pr);
1243 break;
1244 }
1245}
1246
1247void
1248lli_writewakeup(struct PStack *st, int len)
1249{
1250 struct Channel *chanp = st->lli.userdata;
1251 isdn_ctrl ic;
1252
1253 if (chanp->debug & 0x800)
1254 link_debug(chanp, 0, "llwakeup: %d", len);
1255 ic.driver = chanp->cs->myid;
1256 ic.command = ISDN_STAT_BSENT;
1257 ic.arg = chanp->chan;
1258 ic.parm.length = len;
1259 chanp->cs->iif.statcallb(&ic);
1260}
1261
1262static int
1263init_b_st(struct Channel *chanp, int incoming)
1264{
1265 struct PStack *st = chanp->b_st;
1266 struct IsdnCardState *cs = chanp->cs;
1267 char tmp[16];
1268
1269 st->l1.hardware = cs;
1270 if (chanp->leased)
1271 st->l1.bc = chanp->chan & 1;
1272 else
1273 st->l1.bc = chanp->proc->para.bchannel - 1;
1274 switch (chanp->l2_active_protocol) {
1275 case (ISDN_PROTO_L2_X75I):
1276 case (ISDN_PROTO_L2_HDLC):
1277 st->l1.mode = L1_MODE_HDLC;
1278 break;
1279 case (ISDN_PROTO_L2_HDLC_56K):
1280 st->l1.mode = L1_MODE_HDLC_56K;
1281 break;
1282 case (ISDN_PROTO_L2_TRANS):
1283 st->l1.mode = L1_MODE_TRANS;
1284 break;
1285 case (ISDN_PROTO_L2_MODEM):
1286 st->l1.mode = L1_MODE_V32;
1287 break;
1288 case (ISDN_PROTO_L2_FAX):
1289 st->l1.mode = L1_MODE_FAX;
1290 break;
1291 }
1292 chanp->bcs->conmsg = NULL;
1293 if (chanp->bcs->BC_SetStack(st, chanp->bcs))
1294 return (-1);
1295 st->l2.flag = 0;
1296 test_and_set_bit(FLG_LAPB, &st->l2.flag);
1297 st->l2.maxlen = MAX_DATA_SIZE;
1298 if (!incoming)
1299 test_and_set_bit(FLG_ORIG, &st->l2.flag);
1300 st->l2.T200 = 1000;
1301 st->l2.window = 7;
1302 st->l2.N200 = 4;
1303 st->l2.T203 = 5000;
1304 st->l3.debug = 0;
1305 switch (chanp->l2_active_protocol) {
1306 case (ISDN_PROTO_L2_X75I):
1307 sprintf(tmp, "Ch%d X.75", chanp->chan);
1308 setstack_isdnl2(st, tmp);
1309 setstack_l3bc(st, chanp);
1310 st->l2.l2l3 = lldata_handler;
1311 st->lli.userdata = chanp;
1312 test_and_clear_bit(FLG_LLI_L1WAKEUP, &st->lli.flag);
1313 test_and_set_bit(FLG_LLI_L2WAKEUP, &st->lli.flag);
1314 st->l2.l2m.debug = chanp->debug & 16;
1315 st->l2.debug = chanp->debug & 64;
1316 break;
1317 case (ISDN_PROTO_L2_HDLC):
1318 case (ISDN_PROTO_L2_HDLC_56K):
1319 case (ISDN_PROTO_L2_TRANS):
1320 case (ISDN_PROTO_L2_MODEM):
1321 case (ISDN_PROTO_L2_FAX):
1322 st->l1.l1l2 = lltrans_handler;
1323 st->lli.userdata = chanp;
1324 test_and_set_bit(FLG_LLI_L1WAKEUP, &st->lli.flag);
1325 test_and_clear_bit(FLG_LLI_L2WAKEUP, &st->lli.flag);
1326 setstack_transl2(st);
1327 setstack_l3bc(st, chanp);
1328 break;
1329 }
1330 test_and_set_bit(FLG_START_B, &chanp->Flags);
1331 return (0);
1332}
1333
1334static void
1335leased_l4l3(struct PStack *st, int pr, void *arg)
1336{
1337 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1338 struct sk_buff *skb = arg;
1339
1340 switch (pr) {
1341 case (DL_DATA | REQUEST):
1342 link_debug(chanp, 0, "leased line d-channel DATA");
1343 dev_kfree_skb(skb);
1344 break;
1345 case (DL_ESTABLISH | REQUEST):
1346 st->l2.l2l1(st, PH_ACTIVATE | REQUEST, NULL);
1347 break;
1348 case (DL_RELEASE | REQUEST):
1349 break;
1350 default:
1351 printk(KERN_WARNING "transd_l4l3 unknown primitive %#x\n",
1352 pr);
1353 break;
1354 }
1355}
1356
1357static void
1358leased_l1l2(struct PStack *st, int pr, void *arg)
1359{
1360 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1361 struct sk_buff *skb = arg;
1362 int i, event = EV_LEASED_REL;
1363
1364 switch (pr) {
1365 case (PH_DATA | INDICATION):
1366 link_debug(chanp, 0, "leased line d-channel DATA");
1367 dev_kfree_skb(skb);
1368 break;
1369 case (PH_ACTIVATE | INDICATION):
1370 case (PH_ACTIVATE | CONFIRM):
1371 event = EV_LEASED;
1372
1373 case (PH_DEACTIVATE | INDICATION):
1374 case (PH_DEACTIVATE | CONFIRM):
1375 if (test_bit(FLG_TWO_DCHAN, &chanp->cs->HW_Flags))
1376 i = 1;
1377 else
1378 i = 0;
1379 while (i < 2) {
1380 FsmEvent(&chanp->fi, event, NULL);
1381 chanp++;
1382 i++;
1383 }
1384 break;
1385 default:
1386 printk(KERN_WARNING
1387 "transd_l1l2 unknown primitive %#x\n", pr);
1388 break;
1389 }
1390}
1391
1392static void
1393distr_debug(struct IsdnCardState *csta, int debugflags)
1394{
1395 int i;
1396 struct Channel *chanp = csta->channel;
1397
1398 for (i = 0; i < (2 + MAX_WAITING_CALLS); i++) {
1399 chanp[i].debug = debugflags;
1400 chanp[i].fi.debug = debugflags & 2;
1401 chanp[i].d_st->l2.l2m.debug = debugflags & 8;
1402 chanp[i].b_st->l2.l2m.debug = debugflags & 0x10;
1403 chanp[i].d_st->l2.debug = debugflags & 0x20;
1404 chanp[i].b_st->l2.debug = debugflags & 0x40;
1405 chanp[i].d_st->l3.l3m.debug = debugflags & 0x80;
1406 chanp[i].b_st->l3.l3m.debug = debugflags & 0x100;
1407 chanp[i].b_st->ma.tei_m.debug = debugflags & 0x200;
1408 chanp[i].b_st->ma.debug = debugflags & 0x200;
1409 chanp[i].d_st->l1.l1m.debug = debugflags & 0x1000;
1410 chanp[i].b_st->l1.l1m.debug = debugflags & 0x2000;
1411 }
1412 if (debugflags & 4)
1413 csta->debug |= DEB_DLOG_HEX;
1414 else
1415 csta->debug &= ~DEB_DLOG_HEX;
1416}
1417
1418static char tmpbuf[256];
1419
1420static void
1421capi_debug(struct Channel *chanp, capi_msg *cm)
1422{
1423 char *t = tmpbuf;
1424
1425 t += QuickHex(t, (u_char *)cm, (cm->Length > 50) ? 50 : cm->Length);
1426 t--;
1427 *t = 0;
1428 HiSax_putstatus(chanp->cs, "Ch", "%d CAPIMSG %s", chanp->chan, tmpbuf);
1429}
1430
1431static void
1432lli_got_fac_req(struct Channel *chanp, capi_msg *cm) {
1433 if ((cm->para[0] != 3) || (cm->para[1] != 0))
1434 return;
1435 if (cm->para[2] < 3)
1436 return;
1437 if (cm->para[4] != 0)
1438 return;
1439 switch (cm->para[3]) {
1440 case 4:
1441 strncpy(chanp->setup.phone, &cm->para[5], cm->para[5] + 1);
1442 FsmEvent(&chanp->fi, EV_SUSPEND, cm);
1443 break;
1444 case 5:
1445 strncpy(chanp->setup.phone, &cm->para[5], cm->para[5] + 1);
1446 if (chanp->fi.state == ST_NULL) {
1447 FsmEvent(&chanp->fi, EV_RESUME, cm);
1448 } else {
1449 FsmDelTimer(&chanp->dial_timer, 72);
1450 FsmAddTimer(&chanp->dial_timer, 80, EV_RESUME, cm, 73);
1451 }
1452 break;
1453 }
1454}
1455
1456static void
1457lli_got_manufacturer(struct Channel *chanp, struct IsdnCardState *cs, capi_msg *cm) {
1458 if ((cs->typ == ISDN_CTYPE_ELSA) || (cs->typ == ISDN_CTYPE_ELSA_PNP) ||
1459 (cs->typ == ISDN_CTYPE_ELSA_PCI)) {
1460 if (cs->hw.elsa.MFlag) {
1461 cs->cardmsg(cs, CARD_AUX_IND, cm->para);
1462 }
1463 }
1464}
1465
1466
1467
1468
1469
1470static int
1471set_channel_limit(struct IsdnCardState *cs, int chanmax)
1472{
1473 isdn_ctrl ic;
1474 int i, ii;
1475
1476 if ((chanmax < 0) || (chanmax > 2))
1477 return (-EINVAL);
1478 cs->chanlimit = 0;
1479 for (ii = 0; ii < 2; ii++) {
1480 ic.driver = cs->myid;
1481 ic.command = ISDN_STAT_DISCH;
1482 ic.arg = ii;
1483 if (ii >= chanmax)
1484 ic.parm.num[0] = 0;
1485 else
1486 ic.parm.num[0] = 1;
1487 i = cs->iif.statcallb(&ic);
1488 if (i) return (-EINVAL);
1489 if (ii < chanmax)
1490 cs->chanlimit++;
1491 }
1492 return (0);
1493}
1494
1495int
1496HiSax_command(isdn_ctrl *ic)
1497{
1498 struct IsdnCardState *csta = hisax_findcard(ic->driver);
1499 struct PStack *st;
1500 struct Channel *chanp;
1501 int i;
1502 u_int num;
1503
1504 if (!csta) {
1505 printk(KERN_ERR
1506 "HiSax: if_command %d called with invalid driverId %d!\n",
1507 ic->command, ic->driver);
1508 return -ENODEV;
1509 }
1510 switch (ic->command) {
1511 case (ISDN_CMD_SETEAZ):
1512 chanp = csta->channel + ic->arg;
1513 break;
1514 case (ISDN_CMD_SETL2):
1515 chanp = csta->channel + (ic->arg & 0xff);
1516 if (chanp->debug & 1)
1517 link_debug(chanp, 1, "SETL2 card %d %ld",
1518 csta->cardnr + 1, ic->arg >> 8);
1519 chanp->l2_protocol = ic->arg >> 8;
1520 break;
1521 case (ISDN_CMD_SETL3):
1522 chanp = csta->channel + (ic->arg & 0xff);
1523 if (chanp->debug & 1)
1524 link_debug(chanp, 1, "SETL3 card %d %ld",
1525 csta->cardnr + 1, ic->arg >> 8);
1526 chanp->l3_protocol = ic->arg >> 8;
1527 break;
1528 case (ISDN_CMD_DIAL):
1529 chanp = csta->channel + (ic->arg & 0xff);
1530 if (chanp->debug & 1)
1531 link_debug(chanp, 1, "DIAL %s -> %s (%d,%d)",
1532 ic->parm.setup.eazmsn, ic->parm.setup.phone,
1533 ic->parm.setup.si1, ic->parm.setup.si2);
1534 memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
1535 if (!strcmp(chanp->setup.eazmsn, "0"))
1536 chanp->setup.eazmsn[0] = '\0';
1537
1538
1539 if (chanp->fi.state == ST_NULL) {
1540 FsmEvent(&chanp->fi, EV_DIAL, NULL);
1541 } else {
1542 FsmDelTimer(&chanp->dial_timer, 70);
1543 FsmAddTimer(&chanp->dial_timer, 50, EV_DIAL, NULL, 71);
1544 }
1545 break;
1546 case (ISDN_CMD_ACCEPTB):
1547 chanp = csta->channel + ic->arg;
1548 if (chanp->debug & 1)
1549 link_debug(chanp, 1, "ACCEPTB");
1550 FsmEvent(&chanp->fi, EV_ACCEPTB, NULL);
1551 break;
1552 case (ISDN_CMD_ACCEPTD):
1553 chanp = csta->channel + ic->arg;
1554 memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
1555 if (chanp->debug & 1)
1556 link_debug(chanp, 1, "ACCEPTD");
1557 FsmEvent(&chanp->fi, EV_ACCEPTD, NULL);
1558 break;
1559 case (ISDN_CMD_HANGUP):
1560 chanp = csta->channel + ic->arg;
1561 if (chanp->debug & 1)
1562 link_debug(chanp, 1, "HANGUP");
1563 FsmEvent(&chanp->fi, EV_HANGUP, NULL);
1564 break;
1565 case (CAPI_PUT_MESSAGE):
1566 chanp = csta->channel + ic->arg;
1567 if (chanp->debug & 1)
1568 capi_debug(chanp, &ic->parm.cmsg);
1569 if (ic->parm.cmsg.Length < 8)
1570 break;
1571 switch (ic->parm.cmsg.Command) {
1572 case CAPI_FACILITY:
1573 if (ic->parm.cmsg.Subcommand == CAPI_REQ)
1574 lli_got_fac_req(chanp, &ic->parm.cmsg);
1575 break;
1576 case CAPI_MANUFACTURER:
1577 if (ic->parm.cmsg.Subcommand == CAPI_REQ)
1578 lli_got_manufacturer(chanp, csta, &ic->parm.cmsg);
1579 break;
1580 default:
1581 break;
1582 }
1583 break;
1584 case (ISDN_CMD_IOCTL):
1585 switch (ic->arg) {
1586 case (0):
1587 num = *(unsigned int *) ic->parm.num;
1588 HiSax_reportcard(csta->cardnr, num);
1589 break;
1590 case (1):
1591 num = *(unsigned int *) ic->parm.num;
1592 distr_debug(csta, num);
1593 printk(KERN_DEBUG "HiSax: debugging flags card %d set to %x\n",
1594 csta->cardnr + 1, num);
1595 HiSax_putstatus(csta, "debugging flags ",
1596 "card %d set to %x", csta->cardnr + 1, num);
1597 break;
1598 case (2):
1599 num = *(unsigned int *) ic->parm.num;
1600 csta->channel[0].b_st->l1.delay = num;
1601 csta->channel[1].b_st->l1.delay = num;
1602 HiSax_putstatus(csta, "delay ", "card %d set to %d ms",
1603 csta->cardnr + 1, num);
1604 printk(KERN_DEBUG "HiSax: delay card %d set to %d ms\n",
1605 csta->cardnr + 1, num);
1606 break;
1607 case (5):
1608 num = *(unsigned int *) ic->parm.num;
1609 if ((num < 1) || (num > 2)) {
1610 HiSax_putstatus(csta, "Set LEASED ",
1611 "wrong channel %d", num);
1612 printk(KERN_WARNING "HiSax: Set LEASED wrong channel %d\n",
1613 num);
1614 } else {
1615 num--;
1616 chanp = csta->channel + num;
1617 chanp->leased = 1;
1618 HiSax_putstatus(csta, "Card",
1619 "%d channel %d set leased mode\n",
1620 csta->cardnr + 1, num + 1);
1621 chanp->d_st->l1.l1l2 = leased_l1l2;
1622 chanp->d_st->lli.l4l3 = leased_l4l3;
1623 chanp->d_st->lli.l4l3(chanp->d_st,
1624 DL_ESTABLISH | REQUEST, NULL);
1625 }
1626 break;
1627 case (6):
1628 num = *(unsigned int *) ic->parm.num;
1629 if (csta->stlist)
1630 csta->stlist->l2.l2l1(csta->stlist,
1631 PH_TESTLOOP | REQUEST, (void *) (long)num);
1632 break;
1633 case (7):
1634 num = *(unsigned int *) ic->parm.num;
1635 if (test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
1636 printk(KERN_ERR "HiSax PTP mode only with one TEI possible\n");
1637 } else if (num) {
1638 test_and_set_bit(FLG_PTP, &csta->channel[0].d_st->l2.flag);
1639 test_and_set_bit(FLG_FIXED_TEI, &csta->channel[0].d_st->l2.flag);
1640 csta->channel[0].d_st->l2.tei = 0;
1641 HiSax_putstatus(csta, "set card ", "in PTP mode");
1642 printk(KERN_DEBUG "HiSax: set card in PTP mode\n");
1643 printk(KERN_INFO "LAYER2 WATCHING ESTABLISH\n");
1644 csta->channel[0].d_st->lli.l4l3(csta->channel[0].d_st,
1645 DL_ESTABLISH | REQUEST, NULL);
1646 } else {
1647 test_and_clear_bit(FLG_PTP, &csta->channel[0].d_st->l2.flag);
1648 test_and_clear_bit(FLG_FIXED_TEI, &csta->channel[0].d_st->l2.flag);
1649 HiSax_putstatus(csta, "set card ", "in PTMP mode");
1650 printk(KERN_DEBUG "HiSax: set card in PTMP mode\n");
1651 }
1652 break;
1653 case (8):
1654 num = *(unsigned int *)ic->parm.num;
1655 chanp = csta->channel + (num & 1);
1656 num = num >> 1;
1657 if (num == 127) {
1658 test_and_clear_bit(FLG_FIXED_TEI, &chanp->d_st->l2.flag);
1659 chanp->d_st->l2.tei = -1;
1660 HiSax_putstatus(csta, "set card ", "in VAR TEI mode");
1661 printk(KERN_DEBUG "HiSax: set card in VAR TEI mode\n");
1662 } else {
1663 test_and_set_bit(FLG_FIXED_TEI, &chanp->d_st->l2.flag);
1664 chanp->d_st->l2.tei = num;
1665 HiSax_putstatus(csta, "set card ", "in FIXED TEI (%d) mode", num);
1666 printk(KERN_DEBUG "HiSax: set card in FIXED TEI (%d) mode\n",
1667 num);
1668 }
1669 chanp->d_st->lli.l4l3(chanp->d_st,
1670 DL_ESTABLISH | REQUEST, NULL);
1671 break;
1672 case (11):
1673 num = csta->debug & DEB_DLOG_HEX;
1674 csta->debug = *(unsigned int *) ic->parm.num;
1675 csta->debug |= num;
1676 HiSax_putstatus(cards[0].cs, "l1 debugging ",
1677 "flags card %d set to %x",
1678 csta->cardnr + 1, csta->debug);
1679 printk(KERN_DEBUG "HiSax: l1 debugging flags card %d set to %x\n",
1680 csta->cardnr + 1, csta->debug);
1681 break;
1682 case (13):
1683 csta->channel[0].d_st->l3.debug = *(unsigned int *) ic->parm.num;
1684 csta->channel[1].d_st->l3.debug = *(unsigned int *) ic->parm.num;
1685 HiSax_putstatus(cards[0].cs, "l3 debugging ",
1686 "flags card %d set to %x\n", csta->cardnr + 1,
1687 *(unsigned int *) ic->parm.num);
1688 printk(KERN_DEBUG "HiSax: l3 debugging flags card %d set to %x\n",
1689 csta->cardnr + 1, *(unsigned int *) ic->parm.num);
1690 break;
1691 case (10):
1692 i = *(unsigned int *) ic->parm.num;
1693 return (set_channel_limit(csta, i));
1694 default:
1695 if (csta->auxcmd)
1696 return (csta->auxcmd(csta, ic));
1697 printk(KERN_DEBUG "HiSax: invalid ioctl %d\n",
1698 (int) ic->arg);
1699 return (-EINVAL);
1700 }
1701 break;
1702
1703 case (ISDN_CMD_PROCEED):
1704 chanp = csta->channel + ic->arg;
1705 if (chanp->debug & 1)
1706 link_debug(chanp, 1, "PROCEED");
1707 FsmEvent(&chanp->fi, EV_PROCEED, NULL);
1708 break;
1709
1710 case (ISDN_CMD_ALERT):
1711 chanp = csta->channel + ic->arg;
1712 if (chanp->debug & 1)
1713 link_debug(chanp, 1, "ALERT");
1714 FsmEvent(&chanp->fi, EV_ALERT, NULL);
1715 break;
1716
1717 case (ISDN_CMD_REDIR):
1718 chanp = csta->channel + ic->arg;
1719 if (chanp->debug & 1)
1720 link_debug(chanp, 1, "REDIR");
1721 memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
1722 FsmEvent(&chanp->fi, EV_REDIR, NULL);
1723 break;
1724
1725
1726 case (ISDN_CMD_PROT_IO):
1727 for (st = csta->stlist; st; st = st->next)
1728 if (st->protocol == (ic->arg & 0xFF))
1729 return (st->lli.l4l3_proto(st, ic));
1730 return (-EINVAL);
1731 break;
1732 default:
1733 if (csta->auxcmd)
1734 return (csta->auxcmd(csta, ic));
1735 return (-EINVAL);
1736 }
1737 return (0);
1738}
1739
1740int
1741HiSax_writebuf_skb(int id, int chan, int ack, struct sk_buff *skb)
1742{
1743 struct IsdnCardState *csta = hisax_findcard(id);
1744 struct Channel *chanp;
1745 struct PStack *st;
1746 int len = skb->len;
1747 struct sk_buff *nskb;
1748
1749 if (!csta) {
1750 printk(KERN_ERR
1751 "HiSax: if_sendbuf called with invalid driverId!\n");
1752 return -ENODEV;
1753 }
1754 chanp = csta->channel + chan;
1755 st = chanp->b_st;
1756 if (!chanp->data_open) {
1757 link_debug(chanp, 1, "writebuf: channel not open");
1758 return -EIO;
1759 }
1760 if (len > MAX_DATA_SIZE) {
1761 link_debug(chanp, 1, "writebuf: packet too large (%d bytes)", len);
1762 printk(KERN_WARNING "HiSax_writebuf: packet too large (%d bytes) !\n",
1763 len);
1764 return -EINVAL;
1765 }
1766 if (len) {
1767 if ((len + chanp->bcs->tx_cnt) > MAX_DATA_MEM) {
1768
1769
1770
1771 if (chanp->debug & 0x800)
1772 link_debug(chanp, 1, "writebuf: no buffers for %d bytes", len);
1773 return 0;
1774 } else if (chanp->debug & 0x800)
1775 link_debug(chanp, 1, "writebuf %d/%d/%d", len, chanp->bcs->tx_cnt, MAX_DATA_MEM);
1776 nskb = skb_clone(skb, GFP_ATOMIC);
1777 if (nskb) {
1778 nskb->truesize = nskb->len;
1779 if (!ack)
1780 nskb->pkt_type = PACKET_NOACK;
1781 if (chanp->l2_active_protocol == ISDN_PROTO_L2_X75I)
1782 st->l3.l3l2(st, DL_DATA | REQUEST, nskb);
1783 else {
1784 chanp->bcs->tx_cnt += len;
1785 st->l2.l2l1(st, PH_DATA | REQUEST, nskb);
1786 }
1787 dev_kfree_skb(skb);
1788 } else
1789 len = 0;
1790 }
1791 return (len);
1792}
1793
