?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ath5k: fix values for bus error bits in ISR2
[linux-2.6/next.git] / drivers / isdn / hisax / callc.c
blob025a20d487c5df71a8f42d7babc6fc696d308737
1 /* $Id: callc.c,v 2.59.2.4 2004/02/11 13:21:32 keil Exp $
2 *
3 * Author Karsten Keil
4 * Copyright by Karsten Keil <keil@isdn4linux.de>
5 *
6 * This software may be used and distributed according to the terms
7 * of the GNU General Public License, incorporated herein by reference.
8 *
9 * For changes and modifications please read
10 * Documentation/isdn/HiSax.cert
11 *
12 * based on the teles driver from Jan den Ouden
13 *
14 * Thanks to Jan den Ouden
15 * Fritz Elfert
16 *
17 */
18
19 #include <linux/module.h>
20 #include <linux/init.h>
21 #include "hisax.h"
22 #include <linux/isdn/capicmd.h>
23
24 const char *lli_revision = "$Revision: 2.59.2.4 $";
25
26 extern struct IsdnCard cards[];
27
28 static int init_b_st(struct Channel *chanp, int incoming);
29 static void release_b_st(struct Channel *chanp);
30
31 static struct Fsm callcfsm;
32 static int chancount;
33
34 /* experimental REJECT after ALERTING for CALLBACK to beat the 4s delay */
35 #define ALERT_REJECT 0
36
37 /* Value to delay the sending of the first B-channel paket after CONNECT
38 * here is no value given by ITU, but experience shows that 300 ms will
39 * work on many networks, if you or your other side is behind local exchanges
40 * a greater value may be recommented. If the delay is to short the first paket
41 * will be lost and autodetect on many comercial routers goes wrong !
42 * You can adjust this value on runtime with
43 * hisaxctrl <id> 2 <value>
44 * value is in milliseconds
45 */
46 #define DEFAULT_B_DELAY 300
47
48 /* Flags for remembering action done in lli */
49
50 #define FLG_START_B 0
51
52 /*
53 * Find card with given driverId
54 */
55 static inline struct IsdnCardState *
56 hisax_findcard(int driverid)
57 {
58 int i;
59
60 for (i = 0; i < nrcards; i++)
61 if (cards[i].cs)
62 if (cards[i].cs->myid == driverid)
63 return (cards[i].cs);
64 return (struct IsdnCardState *) 0;
65 }
66
67 static void
68 link_debug(struct Channel *chanp, int direction, char *fmt, ...)
69 {
70 va_list args;
71 char tmp[16];
72
73 va_start(args, fmt);
74 sprintf(tmp, "Ch%d %s ", chanp->chan,
75 direction ? "LL->HL" : "HL->LL");
76 VHiSax_putstatus(chanp->cs, tmp, fmt, args);
77 va_end(args);
78 }
79
80 enum {
81 ST_NULL, /* 0 inactive */
82 ST_OUT_DIAL, /* 1 outgoing, SETUP send; awaiting confirm */
83 ST_IN_WAIT_LL, /* 2 incoming call received; wait for LL confirm */
84 ST_IN_ALERT_SENT, /* 3 incoming call received; ALERT send */
85 ST_IN_WAIT_CONN_ACK, /* 4 incoming CONNECT send; awaiting CONN_ACK */
86 ST_WAIT_BCONN, /* 5 CONNECT/CONN_ACK received, awaiting b-channel prot. estbl. */
87 ST_ACTIVE, /* 6 active, b channel prot. established */
88 ST_WAIT_BRELEASE, /* 7 call clear. (initiator), awaiting b channel prot. rel. */
89 ST_WAIT_BREL_DISC, /* 8 call clear. (receiver), DISCONNECT req. received */
90 ST_WAIT_DCOMMAND, /* 9 call clear. (receiver), awaiting DCHANNEL message */
91 ST_WAIT_DRELEASE, /* 10 DISCONNECT sent, awaiting RELEASE */
92 ST_WAIT_D_REL_CNF, /* 11 RELEASE sent, awaiting RELEASE confirm */
93 ST_IN_PROCEED_SEND, /* 12 incoming call, proceeding send */
94 };
95
96
97 #define STATE_COUNT (ST_IN_PROCEED_SEND + 1)
98
99 static char *strState[] =
100 {
101 "ST_NULL",
102 "ST_OUT_DIAL",
103 "ST_IN_WAIT_LL",
104 "ST_IN_ALERT_SENT",
105 "ST_IN_WAIT_CONN_ACK",
106 "ST_WAIT_BCONN",
107 "ST_ACTIVE",
108 "ST_WAIT_BRELEASE",
109 "ST_WAIT_BREL_DISC",
110 "ST_WAIT_DCOMMAND",
111 "ST_WAIT_DRELEASE",
112 "ST_WAIT_D_REL_CNF",
113 "ST_IN_PROCEED_SEND",
114 };
115
116 enum {
117 EV_DIAL, /* 0 */
118 EV_SETUP_CNF, /* 1 */
119 EV_ACCEPTB, /* 2 */
120 EV_DISCONNECT_IND, /* 3 */
121 EV_RELEASE, /* 4 */
122 EV_LEASED, /* 5 */
123 EV_LEASED_REL, /* 6 */
124 EV_SETUP_IND, /* 7 */
125 EV_ACCEPTD, /* 8 */
126 EV_SETUP_CMPL_IND, /* 9 */
127 EV_BC_EST, /* 10 */
128 EV_WRITEBUF, /* 11 */
129 EV_HANGUP, /* 12 */
130 EV_BC_REL, /* 13 */
131 EV_CINF, /* 14 */
132 EV_SUSPEND, /* 15 */
133 EV_RESUME, /* 16 */
134 EV_NOSETUP_RSP, /* 17 */
135 EV_SETUP_ERR, /* 18 */
136 EV_CONNECT_ERR, /* 19 */
137 EV_PROCEED, /* 20 */
138 EV_ALERT, /* 21 */
139 EV_REDIR, /* 22 */
140 };
141
142 #define EVENT_COUNT (EV_REDIR + 1)
143
144 static char *strEvent[] =
145 {
146 "EV_DIAL",
147 "EV_SETUP_CNF",
148 "EV_ACCEPTB",
149 "EV_DISCONNECT_IND",
150 "EV_RELEASE",
151 "EV_LEASED",
152 "EV_LEASED_REL",
153 "EV_SETUP_IND",
154 "EV_ACCEPTD",
155 "EV_SETUP_CMPL_IND",
156 "EV_BC_EST",
157 "EV_WRITEBUF",
158 "EV_HANGUP",
159 "EV_BC_REL",
160 "EV_CINF",
161 "EV_SUSPEND",
162 "EV_RESUME",
163 "EV_NOSETUP_RSP",
164 "EV_SETUP_ERR",
165 "EV_CONNECT_ERR",
166 "EV_PROCEED",
167 "EV_ALERT",
168 "EV_REDIR",
169 };
170
171
172 static inline void
173 HL_LL(struct Channel *chanp, int command)
174 {
175 isdn_ctrl ic;
176
177 ic.driver = chanp->cs->myid;
178 ic.command = command;
179 ic.arg = chanp->chan;
180 chanp->cs->iif.statcallb(&ic);
181 }
182
183 static inline void
184 lli_deliver_cause(struct Channel *chanp)
185 {
186 isdn_ctrl ic;
187
188 if (!chanp->proc)
189 return;
190 if (chanp->proc->para.cause == NO_CAUSE)
191 return;
192 ic.driver = chanp->cs->myid;
193 ic.command = ISDN_STAT_CAUSE;
194 ic.arg = chanp->chan;
195 if (chanp->cs->protocol == ISDN_PTYPE_EURO)
196 sprintf(ic.parm.num, "E%02X%02X", chanp->proc->para.loc & 0x7f,
197 chanp->proc->para.cause & 0x7f);
198 else
199 sprintf(ic.parm.num, "%02X%02X", chanp->proc->para.loc & 0x7f,
200 chanp->proc->para.cause & 0x7f);
201 chanp->cs->iif.statcallb(&ic);
202 }
203
204 static inline void
205 lli_close(struct FsmInst *fi)
206 {
207 struct Channel *chanp = fi->userdata;
208
209 FsmChangeState(fi, ST_NULL);
210 chanp->Flags = 0;
211 chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
212 }
213
214 static void
215 lli_leased_in(struct FsmInst *fi, int event, void *arg)
216 {
217 struct Channel *chanp = fi->userdata;
218 isdn_ctrl ic;
219 int ret;
220
221 if (!chanp->leased)
222 return;
223 chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
224 FsmChangeState(fi, ST_IN_WAIT_LL);
225 if (chanp->debug & 1)
226 link_debug(chanp, 0, "STAT_ICALL_LEASED");
227 ic.driver = chanp->cs->myid;
228 ic.command = ((chanp->chan < 2) ? ISDN_STAT_ICALL : ISDN_STAT_ICALLW);
229 ic.arg = chanp->chan;
230 ic.parm.setup.si1 = 7;
231 ic.parm.setup.si2 = 0;
232 ic.parm.setup.plan = 0;
233 ic.parm.setup.screen = 0;
234 sprintf(ic.parm.setup.eazmsn,"%d", chanp->chan + 1);
235 sprintf(ic.parm.setup.phone,"LEASED%d", chanp->cs->myid);
236 ret = chanp->cs->iif.statcallb(&ic);
237 if (chanp->debug & 1)
238 link_debug(chanp, 1, "statcallb ret=%d", ret);
239 if (!ret) {
240 chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
241 FsmChangeState(fi, ST_NULL);
242 }
243 }
244
245
246 /*
247 * Dial out
248 */
249 static void
250 lli_init_bchan_out(struct FsmInst *fi, int event, void *arg)
251 {
252 struct Channel *chanp = fi->userdata;
253
254 FsmChangeState(fi, ST_WAIT_BCONN);
255 if (chanp->debug & 1)
256 link_debug(chanp, 0, "STAT_DCONN");
257 HL_LL(chanp, ISDN_STAT_DCONN);
258 init_b_st(chanp, 0);
259 chanp->b_st->lli.l4l3(chanp->b_st, DL_ESTABLISH | REQUEST, NULL);
260 }
261
262 static void
263 lli_prep_dialout(struct FsmInst *fi, int event, void *arg)
264 {
265 struct Channel *chanp = fi->userdata;
266
267 FsmDelTimer(&chanp->drel_timer, 60);
268 FsmDelTimer(&chanp->dial_timer, 73);
269 chanp->l2_active_protocol = chanp->l2_protocol;
270 chanp->incoming = 0;
271 chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
272 if (chanp->leased) {
273 lli_init_bchan_out(fi, event, arg);
274 } else {
275 FsmChangeState(fi, ST_OUT_DIAL);
276 chanp->d_st->lli.l4l3(chanp->d_st, CC_SETUP | REQUEST, chanp);
277 }
278 }
279
280 static void
281 lli_resume(struct FsmInst *fi, int event, void *arg)
282 {
283 struct Channel *chanp = fi->userdata;
284
285 FsmDelTimer(&chanp->drel_timer, 60);
286 FsmDelTimer(&chanp->dial_timer, 73);
287 chanp->l2_active_protocol = chanp->l2_protocol;
288 chanp->incoming = 0;
289 chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
290 if (chanp->leased) {
291 lli_init_bchan_out(fi, event, arg);
292 } else {
293 FsmChangeState(fi, ST_OUT_DIAL);
294 chanp->d_st->lli.l4l3(chanp->d_st, CC_RESUME | REQUEST, chanp);
295 }
296 }
297
298 static void
299 lli_go_active(struct FsmInst *fi, int event, void *arg)
300 {
301 struct Channel *chanp = fi->userdata;
302 isdn_ctrl ic;
303
304
305 FsmChangeState(fi, ST_ACTIVE);
306 chanp->data_open = !0;
307 if (chanp->bcs->conmsg)
308 strcpy(ic.parm.num, chanp->bcs->conmsg);
309 else
310 ic.parm.num[0] = 0;
311 if (chanp->debug & 1)
312 link_debug(chanp, 0, "STAT_BCONN %s", ic.parm.num);
313 ic.driver = chanp->cs->myid;
314 ic.command = ISDN_STAT_BCONN;
315 ic.arg = chanp->chan;
316 chanp->cs->iif.statcallb(&ic);
317 chanp->cs->cardmsg(chanp->cs, MDL_INFO_CONN, (void *) (long)chanp->chan);
318 }
319
320
321 /*
322 * RESUME
323 */
324
325 /* incoming call */
326
327 static void
328 lli_deliver_call(struct FsmInst *fi, int event, void *arg)
329 {
330 struct Channel *chanp = fi->userdata;
331 isdn_ctrl ic;
332 int ret;
333
334 chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
335 /*
336 * Report incoming calls only once to linklevel, use CallFlags
337 * which is set to 3 with each broadcast message in isdnl1.c
338 * and resetted if a interface answered the STAT_ICALL.
339 */
340 if (1) { /* for only one TEI */
341 FsmChangeState(fi, ST_IN_WAIT_LL);
342 if (chanp->debug & 1)
343 link_debug(chanp, 0, (chanp->chan < 2) ? "STAT_ICALL" : "STAT_ICALLW");
344 ic.driver = chanp->cs->myid;
345 ic.command = ((chanp->chan < 2) ? ISDN_STAT_ICALL : ISDN_STAT_ICALLW);
346
347 ic.arg = chanp->chan;
348 /*
349 * No need to return "unknown" for calls without OAD,
350 * cause that's handled in linklevel now (replaced by '0')
351 */
352 memcpy(&ic.parm.setup, &chanp->proc->para.setup, sizeof(setup_parm));
353 ret = chanp->cs->iif.statcallb(&ic);
354 if (chanp->debug & 1)
355 link_debug(chanp, 1, "statcallb ret=%d", ret);
356
357 switch (ret) {
358 case 1: /* OK, someone likes this call */
359 FsmDelTimer(&chanp->drel_timer, 61);
360 FsmChangeState(fi, ST_IN_ALERT_SENT);
361 chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
362 break;
363 case 5: /* direct redirect */
364 case 4: /* Proceeding desired */
365 FsmDelTimer(&chanp->drel_timer, 61);
366 FsmChangeState(fi, ST_IN_PROCEED_SEND);
367 chanp->d_st->lli.l4l3(chanp->d_st, CC_PROCEED_SEND | REQUEST, chanp->proc);
368 if (ret == 5) {
369 memcpy(&chanp->setup, &ic.parm.setup, sizeof(setup_parm));
370 chanp->d_st->lli.l4l3(chanp->d_st, CC_REDIR | REQUEST, chanp->proc);
371 }
372 break;
373 case 2: /* Rejecting Call */
374 break;
375 case 3: /* incomplete number */
376 FsmDelTimer(&chanp->drel_timer, 61);
377 chanp->d_st->lli.l4l3(chanp->d_st, CC_MORE_INFO | REQUEST, chanp->proc);
378 break;
379 case 0: /* OK, nobody likes this call */
380 default: /* statcallb problems */
381 chanp->d_st->lli.l4l3(chanp->d_st, CC_IGNORE | REQUEST, chanp->proc);
382 chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
383 FsmChangeState(fi, ST_NULL);
384 break;
385 }
386 } else {
387 chanp->d_st->lli.l4l3(chanp->d_st, CC_IGNORE | REQUEST, chanp->proc);
388 chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
389 }
390 }
391
392 static void
393 lli_send_dconnect(struct FsmInst *fi, int event, void *arg)
394 {
395 struct Channel *chanp = fi->userdata;
396
397 FsmChangeState(fi, ST_IN_WAIT_CONN_ACK);
398 chanp->d_st->lli.l4l3(chanp->d_st, CC_SETUP | RESPONSE, chanp->proc);
399 }
400
401 static void
402 lli_send_alert(struct FsmInst *fi, int event, void *arg)
403 {
404 struct Channel *chanp = fi->userdata;
405
406 FsmChangeState(fi, ST_IN_ALERT_SENT);
407 chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
408 }
409
410 static void
411 lli_send_redir(struct FsmInst *fi, int event, void *arg)
412 {
413 struct Channel *chanp = fi->userdata;
414
415 chanp->d_st->lli.l4l3(chanp->d_st, CC_REDIR | REQUEST, chanp->proc);
416 }
417
418 static void
419 lli_init_bchan_in(struct FsmInst *fi, int event, void *arg)
420 {
421 struct Channel *chanp = fi->userdata;
422
423 FsmChangeState(fi, ST_WAIT_BCONN);
424 if (chanp->debug & 1)
425 link_debug(chanp, 0, "STAT_DCONN");
426 HL_LL(chanp, ISDN_STAT_DCONN);
427 chanp->l2_active_protocol = chanp->l2_protocol;
428 chanp->incoming = !0;
429 init_b_st(chanp, !0);
430 chanp->b_st->lli.l4l3(chanp->b_st, DL_ESTABLISH | REQUEST, NULL);
431 }
432
433 static void
434 lli_setup_rsp(struct FsmInst *fi, int event, void *arg)
435 {
436 struct Channel *chanp = fi->userdata;
437
438 if (chanp->leased) {
439 lli_init_bchan_in(fi, event, arg);
440 } else {
441 FsmChangeState(fi, ST_IN_WAIT_CONN_ACK);
442 #ifdef WANT_ALERT
443 chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
444 #endif
445 chanp->d_st->lli.l4l3(chanp->d_st, CC_SETUP | RESPONSE, chanp->proc);
446 }
447 }
448
449 /* Call suspend */
450
451 static void
452 lli_suspend(struct FsmInst *fi, int event, void *arg)
453 {
454 struct Channel *chanp = fi->userdata;
455
456 chanp->d_st->lli.l4l3(chanp->d_st, CC_SUSPEND | REQUEST, chanp->proc);
457 }
458
459 /* Call clearing */
460
461 static void
462 lli_leased_hup(struct FsmInst *fi, struct Channel *chanp)
463 {
464 isdn_ctrl ic;
465
466 ic.driver = chanp->cs->myid;
467 ic.command = ISDN_STAT_CAUSE;
468 ic.arg = chanp->chan;
469 sprintf(ic.parm.num, "L0010");
470 chanp->cs->iif.statcallb(&ic);
471 if (chanp->debug & 1)
472 link_debug(chanp, 0, "STAT_DHUP");
473 HL_LL(chanp, ISDN_STAT_DHUP);
474 lli_close(fi);
475 }
476
477 static void
478 lli_disconnect_req(struct FsmInst *fi, int event, void *arg)
479 {
480 struct Channel *chanp = fi->userdata;
481
482 if (chanp->leased) {
483 lli_leased_hup(fi, chanp);
484 } else {
485 FsmChangeState(fi, ST_WAIT_DRELEASE);
486 if (chanp->proc)
487 chanp->proc->para.cause = 0x10; /* Normal Call Clearing */
488 chanp->d_st->lli.l4l3(chanp->d_st, CC_DISCONNECT | REQUEST,
489 chanp->proc);
490 }
491 }
492
493 static void
494 lli_disconnect_reject(struct FsmInst *fi, int event, void *arg)
495 {
496 struct Channel *chanp = fi->userdata;
497
498 if (chanp->leased) {
499 lli_leased_hup(fi, chanp);
500 } else {
501 FsmChangeState(fi, ST_WAIT_DRELEASE);
502 if (chanp->proc)
503 chanp->proc->para.cause = 0x15; /* Call Rejected */
504 chanp->d_st->lli.l4l3(chanp->d_st, CC_DISCONNECT | REQUEST,
505 chanp->proc);
506 }
507 }
508
509 static void
510 lli_dhup_close(struct FsmInst *fi, int event, void *arg)
511 {
512 struct Channel *chanp = fi->userdata;
513
514 if (chanp->leased) {
515 lli_leased_hup(fi, chanp);
516 } else {
517 if (chanp->debug & 1)
518 link_debug(chanp, 0, "STAT_DHUP");
519 lli_deliver_cause(chanp);
520 HL_LL(chanp, ISDN_STAT_DHUP);
521 lli_close(fi);
522 }
523 }
524
525 static void
526 lli_reject_req(struct FsmInst *fi, int event, void *arg)
527 {
528 struct Channel *chanp = fi->userdata;
529
530 if (chanp->leased) {
531 lli_leased_hup(fi, chanp);
532 return;
533 }
534 #ifndef ALERT_REJECT
535 if (chanp->proc)
536 chanp->proc->para.cause = 0x15; /* Call Rejected */
537 chanp->d_st->lli.l4l3(chanp->d_st, CC_REJECT | REQUEST, chanp->proc);
538 lli_dhup_close(fi, event, arg);
539 #else
540 FsmRestartTimer(&chanp->drel_timer, 40, EV_HANGUP, NULL, 63);
541 FsmChangeState(fi, ST_IN_ALERT_SENT);
542 chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
543 #endif
544 }
545
546 static void
547 lli_disconn_bchan(struct FsmInst *fi, int event, void *arg)
548 {
549 struct Channel *chanp = fi->userdata;
550
551 chanp->data_open = 0;
552 FsmChangeState(fi, ST_WAIT_BRELEASE);
553 chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
554 }
555
556 static void
557 lli_start_disc(struct FsmInst *fi, int event, void *arg)
558 {
559 struct Channel *chanp = fi->userdata;
560
561 if (chanp->leased) {
562 lli_leased_hup(fi, chanp);
563 } else {
564 lli_disconnect_req(fi, event, arg);
565 }
566 }
567
568 static void
569 lli_rel_b_disc(struct FsmInst *fi, int event, void *arg)
570 {
571 struct Channel *chanp = fi->userdata;
572
573 release_b_st(chanp);
574 lli_start_disc(fi, event, arg);
575 }
576
577 static void
578 lli_bhup_disc(struct FsmInst *fi, int event, void *arg)
579 {
580 struct Channel *chanp = fi->userdata;
581
582 if (chanp->debug & 1)
583 link_debug(chanp, 0, "STAT_BHUP");
584 HL_LL(chanp, ISDN_STAT_BHUP);
585 lli_rel_b_disc(fi, event, arg);
586 }
587
588 static void
589 lli_bhup_rel_b(struct FsmInst *fi, int event, void *arg)
590 {
591 struct Channel *chanp = fi->userdata;
592
593 FsmChangeState(fi, ST_WAIT_DCOMMAND);
594 chanp->data_open = 0;
595 if (chanp->debug & 1)
596 link_debug(chanp, 0, "STAT_BHUP");
597 HL_LL(chanp, ISDN_STAT_BHUP);
598 release_b_st(chanp);
599 }
600
601 static void
602 lli_release_bchan(struct FsmInst *fi, int event, void *arg)
603 {
604 struct Channel *chanp = fi->userdata;
605
606 chanp->data_open = 0;
607 FsmChangeState(fi, ST_WAIT_BREL_DISC);
608 chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
609 }
610
611
612 static void
613 lli_rel_b_dhup(struct FsmInst *fi, int event, void *arg)
614 {
615 struct Channel *chanp = fi->userdata;
616
617 release_b_st(chanp);
618 lli_dhup_close(fi, event, arg);
619 }
620
621 static void
622 lli_bhup_dhup(struct FsmInst *fi, int event, void *arg)
623 {
624 struct Channel *chanp = fi->userdata;
625
626 if (chanp->debug & 1)
627 link_debug(chanp, 0, "STAT_BHUP");
628 HL_LL(chanp, ISDN_STAT_BHUP);
629 lli_rel_b_dhup(fi, event, arg);
630 }
631
632 static void
633 lli_abort(struct FsmInst *fi, int event, void *arg)
634 {
635 struct Channel *chanp = fi->userdata;
636
637 chanp->data_open = 0;
638 chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
639 lli_bhup_dhup(fi, event, arg);
640 }
641
642 static void
643 lli_release_req(struct FsmInst *fi, int event, void *arg)
644 {
645 struct Channel *chanp = fi->userdata;
646
647 if (chanp->leased) {
648 lli_leased_hup(fi, chanp);
649 } else {
650 FsmChangeState(fi, ST_WAIT_D_REL_CNF);
651 chanp->d_st->lli.l4l3(chanp->d_st, CC_RELEASE | REQUEST,
652 chanp->proc);
653 }
654 }
655
656 static void
657 lli_rel_b_release_req(struct FsmInst *fi, int event, void *arg)
658 {
659 struct Channel *chanp = fi->userdata;
660
661 release_b_st(chanp);
662 lli_release_req(fi, event, arg);
663 }
664
665 static void
666 lli_bhup_release_req(struct FsmInst *fi, int event, void *arg)
667 {
668 struct Channel *chanp = fi->userdata;
669
670 if (chanp->debug & 1)
671 link_debug(chanp, 0, "STAT_BHUP");
672 HL_LL(chanp, ISDN_STAT_BHUP);
673 lli_rel_b_release_req(fi, event, arg);
674 }
675
676
677 /* processing charge info */
678 static void
679 lli_charge_info(struct FsmInst *fi, int event, void *arg)
680 {
681 struct Channel *chanp = fi->userdata;
682 isdn_ctrl ic;
683
684 ic.driver = chanp->cs->myid;
685 ic.command = ISDN_STAT_CINF;
686 ic.arg = chanp->chan;
687 sprintf(ic.parm.num, "%d", chanp->proc->para.chargeinfo);
688 chanp->cs->iif.statcallb(&ic);
689 }
690
691 /* error procedures */
692
693 static void
694 lli_dchan_not_ready(struct FsmInst *fi, int event, void *arg)
695 {
696 struct Channel *chanp = fi->userdata;
697
698 if (chanp->debug & 1)
699 link_debug(chanp, 0, "STAT_DHUP");
700 HL_LL(chanp, ISDN_STAT_DHUP);
701 }
702
703 static void
704 lli_no_setup_rsp(struct FsmInst *fi, int event, void *arg)
705 {
706 struct Channel *chanp = fi->userdata;
707
708 if (chanp->debug & 1)
709 link_debug(chanp, 0, "STAT_DHUP");
710 HL_LL(chanp, ISDN_STAT_DHUP);
711 lli_close(fi);
712 }
713
714 static void
715 lli_error(struct FsmInst *fi, int event, void *arg)
716 {
717 FsmChangeState(fi, ST_WAIT_DRELEASE);
718 }
719
720 static void
721 lli_failure_l(struct FsmInst *fi, int event, void *arg)
722 {
723 struct Channel *chanp = fi->userdata;
724 isdn_ctrl ic;
725
726 FsmChangeState(fi, ST_NULL);
727 ic.driver = chanp->cs->myid;
728 ic.command = ISDN_STAT_CAUSE;
729 ic.arg = chanp->chan;
730 sprintf(ic.parm.num, "L%02X%02X", 0, 0x2f);
731 chanp->cs->iif.statcallb(&ic);
732 HL_LL(chanp, ISDN_STAT_DHUP);
733 chanp->Flags = 0;
734 chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
735 }
736
737 static void
738 lli_rel_b_fail(struct FsmInst *fi, int event, void *arg)
739 {
740 struct Channel *chanp = fi->userdata;
741
742 release_b_st(chanp);
743 lli_failure_l(fi, event, arg);
744 }
745
746 static void
747 lli_bhup_fail(struct FsmInst *fi, int event, void *arg)
748 {
749 struct Channel *chanp = fi->userdata;
750
751 if (chanp->debug & 1)
752 link_debug(chanp, 0, "STAT_BHUP");
753 HL_LL(chanp, ISDN_STAT_BHUP);
754 lli_rel_b_fail(fi, event, arg);
755 }
756
757 static void
758 lli_failure_a(struct FsmInst *fi, int event, void *arg)
759 {
760 struct Channel *chanp = fi->userdata;
761
762 chanp->data_open = 0;
763 chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
764 lli_bhup_fail(fi, event, arg);
765 }
766
767 /* *INDENT-OFF* */
768 static struct FsmNode fnlist[] __initdata =
769 {
770 {ST_NULL, EV_DIAL, lli_prep_dialout},
771 {ST_NULL, EV_RESUME, lli_resume},
772 {ST_NULL, EV_SETUP_IND, lli_deliver_call},
773 {ST_NULL, EV_LEASED, lli_leased_in},
774 {ST_OUT_DIAL, EV_SETUP_CNF, lli_init_bchan_out},
775 {ST_OUT_DIAL, EV_HANGUP, lli_disconnect_req},
776 {ST_OUT_DIAL, EV_DISCONNECT_IND, lli_release_req},
777 {ST_OUT_DIAL, EV_RELEASE, lli_dhup_close},
778 {ST_OUT_DIAL, EV_NOSETUP_RSP, lli_no_setup_rsp},
779 {ST_OUT_DIAL, EV_SETUP_ERR, lli_error},
780 {ST_IN_WAIT_LL, EV_LEASED_REL, lli_failure_l},
781 {ST_IN_WAIT_LL, EV_ACCEPTD, lli_setup_rsp},
782 {ST_IN_WAIT_LL, EV_HANGUP, lli_reject_req},
783 {ST_IN_WAIT_LL, EV_DISCONNECT_IND, lli_release_req},
784 {ST_IN_WAIT_LL, EV_RELEASE, lli_dhup_close},
785 {ST_IN_WAIT_LL, EV_SETUP_IND, lli_deliver_call},
786 {ST_IN_WAIT_LL, EV_SETUP_ERR, lli_error},
787 {ST_IN_ALERT_SENT, EV_SETUP_CMPL_IND, lli_init_bchan_in},
788 {ST_IN_ALERT_SENT, EV_ACCEPTD, lli_send_dconnect},
789 {ST_IN_ALERT_SENT, EV_HANGUP, lli_disconnect_reject},
790 {ST_IN_ALERT_SENT, EV_DISCONNECT_IND, lli_release_req},
791 {ST_IN_ALERT_SENT, EV_RELEASE, lli_dhup_close},
792 {ST_IN_ALERT_SENT, EV_REDIR, lli_send_redir},
793 {ST_IN_PROCEED_SEND, EV_REDIR, lli_send_redir},
794 {ST_IN_PROCEED_SEND, EV_ALERT, lli_send_alert},
795 {ST_IN_PROCEED_SEND, EV_ACCEPTD, lli_send_dconnect},
796 {ST_IN_PROCEED_SEND, EV_HANGUP, lli_disconnect_reject},
797 {ST_IN_PROCEED_SEND, EV_DISCONNECT_IND, lli_dhup_close},
798 {ST_IN_ALERT_SENT, EV_RELEASE, lli_dhup_close},
799 {ST_IN_WAIT_CONN_ACK, EV_SETUP_CMPL_IND, lli_init_bchan_in},
800 {ST_IN_WAIT_CONN_ACK, EV_HANGUP, lli_disconnect_req},
801 {ST_IN_WAIT_CONN_ACK, EV_DISCONNECT_IND, lli_release_req},
802 {ST_IN_WAIT_CONN_ACK, EV_RELEASE, lli_dhup_close},
803 {ST_IN_WAIT_CONN_ACK, EV_CONNECT_ERR, lli_error},
804 {ST_WAIT_BCONN, EV_BC_EST, lli_go_active},
805 {ST_WAIT_BCONN, EV_BC_REL, lli_rel_b_disc},
806 {ST_WAIT_BCONN, EV_HANGUP, lli_rel_b_disc},
807 {ST_WAIT_BCONN, EV_DISCONNECT_IND, lli_rel_b_release_req},
808 {ST_WAIT_BCONN, EV_RELEASE, lli_rel_b_dhup},
809 {ST_WAIT_BCONN, EV_LEASED_REL, lli_rel_b_fail},
810 {ST_WAIT_BCONN, EV_CINF, lli_charge_info},
811 {ST_ACTIVE, EV_CINF, lli_charge_info},
812 {ST_ACTIVE, EV_BC_REL, lli_bhup_rel_b},
813 {ST_ACTIVE, EV_SUSPEND, lli_suspend},
814 {ST_ACTIVE, EV_HANGUP, lli_disconn_bchan},
815 {ST_ACTIVE, EV_DISCONNECT_IND, lli_release_bchan},
816 {ST_ACTIVE, EV_RELEASE, lli_abort},
817 {ST_ACTIVE, EV_LEASED_REL, lli_failure_a},
818 {ST_WAIT_BRELEASE, EV_BC_REL, lli_bhup_disc},
819 {ST_WAIT_BRELEASE, EV_DISCONNECT_IND, lli_bhup_release_req},
820 {ST_WAIT_BRELEASE, EV_RELEASE, lli_bhup_dhup},
821 {ST_WAIT_BRELEASE, EV_LEASED_REL, lli_bhup_fail},
822 {ST_WAIT_BREL_DISC, EV_BC_REL, lli_bhup_release_req},
823 {ST_WAIT_BREL_DISC, EV_RELEASE, lli_bhup_dhup},
824 {ST_WAIT_DCOMMAND, EV_HANGUP, lli_start_disc},
825 {ST_WAIT_DCOMMAND, EV_DISCONNECT_IND, lli_release_req},
826 {ST_WAIT_DCOMMAND, EV_RELEASE, lli_dhup_close},
827 {ST_WAIT_DCOMMAND, EV_LEASED_REL, lli_failure_l},
828 {ST_WAIT_DRELEASE, EV_RELEASE, lli_dhup_close},
829 {ST_WAIT_DRELEASE, EV_DIAL, lli_dchan_not_ready},
830 /* ETS 300-104 16.1 */
831 {ST_WAIT_D_REL_CNF, EV_RELEASE, lli_dhup_close},
832 {ST_WAIT_D_REL_CNF, EV_DIAL, lli_dchan_not_ready},
833 };
834 /* *INDENT-ON* */
835
836 #define FNCOUNT (sizeof(fnlist)/sizeof(struct FsmNode))
837
838 int __init
839 CallcNew(void)
840 {
841 callcfsm.state_count = STATE_COUNT;
842 callcfsm.event_count = EVENT_COUNT;
843 callcfsm.strEvent = strEvent;
844 callcfsm.strState = strState;
845 return FsmNew(&callcfsm, fnlist, FNCOUNT);
846 }
847
848 void
849 CallcFree(void)
850 {
851 FsmFree(&callcfsm);
852 }
853
854 static void
855 release_b_st(struct Channel *chanp)
856 {
857 struct PStack *st = chanp->b_st;
858
859 if(test_and_clear_bit(FLG_START_B, &chanp->Flags)) {
860 chanp->bcs->BC_Close(chanp->bcs);
861 switch (chanp->l2_active_protocol) {
862 case (ISDN_PROTO_L2_X75I):
863 releasestack_isdnl2(st);
864 break;
865 case (ISDN_PROTO_L2_HDLC):
866 case (ISDN_PROTO_L2_HDLC_56K):
867 case (ISDN_PROTO_L2_TRANS):
868 case (ISDN_PROTO_L2_MODEM):
869 case (ISDN_PROTO_L2_FAX):
870 releasestack_transl2(st);
871 break;
872 }
873 }
874 }
875
876 static struct Channel
877 *selectfreechannel(struct PStack *st, int bch)
878 {
879 struct IsdnCardState *cs = st->l1.hardware;
880 struct Channel *chanp = st->lli.userdata;
881 int i;
882
883 if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
884 i=1;
885 else
886 i=0;
887
888 if (!bch) {
889 i = 2; /* virtual channel */
890 chanp += 2;
891 }
892
893 while (i < ((bch) ? cs->chanlimit : (2 + MAX_WAITING_CALLS))) {
894 if (chanp->fi.state == ST_NULL)
895 return (chanp);
896 chanp++;
897 i++;
898 }
899
900 if (bch) /* number of channels is limited */ {
901 i = 2; /* virtual channel */
902 chanp = st->lli.userdata;
903 chanp += i;
904 while (i < (2 + MAX_WAITING_CALLS)) {
905 if (chanp->fi.state == ST_NULL)
906 return (chanp);
907 chanp++;
908 i++;
909 }
910 }
911 return (NULL);
912 }
913
914 static void stat_redir_result(struct IsdnCardState *cs, int chan, ulong result)
915 { isdn_ctrl ic;
916
917 ic.driver = cs->myid;
918 ic.command = ISDN_STAT_REDIR;
919 ic.arg = chan;
920 ic.parm.num[0] = result;
921 cs->iif.statcallb(&ic);
922 } /* stat_redir_result */
923
924 static void
925 dchan_l3l4(struct PStack *st, int pr, void *arg)
926 {
927 struct l3_process *pc = arg;
928 struct IsdnCardState *cs = st->l1.hardware;
929 struct Channel *chanp;
930
931 if(!pc)
932 return;
933
934 if (pr == (CC_SETUP | INDICATION)) {
935 if (!(chanp = selectfreechannel(pc->st, pc->para.bchannel))) {
936 pc->para.cause = 0x11; /* User busy */
937 pc->st->lli.l4l3(pc->st, CC_REJECT | REQUEST, pc);
938 } else {
939 chanp->proc = pc;
940 pc->chan = chanp;
941 FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
942 }
943 return;
944 }
945 if (!(chanp = pc->chan))
946 return;
947
948 switch (pr) {
949 case (CC_MORE_INFO | INDICATION):
950 FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
951 break;
952 case (CC_DISCONNECT | INDICATION):
953 FsmEvent(&chanp->fi, EV_DISCONNECT_IND, NULL);
954 break;
955 case (CC_RELEASE | CONFIRM):
956 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
957 break;
958 case (CC_SUSPEND | CONFIRM):
959 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
960 break;
961 case (CC_RESUME | CONFIRM):
962 FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
963 break;
964 case (CC_RESUME_ERR):
965 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
966 break;
967 case (CC_RELEASE | INDICATION):
968 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
969 break;
970 case (CC_SETUP_COMPL | INDICATION):
971 FsmEvent(&chanp->fi, EV_SETUP_CMPL_IND, NULL);
972 break;
973 case (CC_SETUP | CONFIRM):
974 FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
975 break;
976 case (CC_CHARGE | INDICATION):
977 FsmEvent(&chanp->fi, EV_CINF, NULL);
978 break;
979 case (CC_NOSETUP_RSP):
980 FsmEvent(&chanp->fi, EV_NOSETUP_RSP, NULL);
981 break;
982 case (CC_SETUP_ERR):
983 FsmEvent(&chanp->fi, EV_SETUP_ERR, NULL);
984 break;
985 case (CC_CONNECT_ERR):
986 FsmEvent(&chanp->fi, EV_CONNECT_ERR, NULL);
987 break;
988 case (CC_RELEASE_ERR):
989 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
990 break;
991 case (CC_PROCEED_SEND | INDICATION):
992 case (CC_PROCEEDING | INDICATION):
993 case (CC_ALERTING | INDICATION):
994 case (CC_PROGRESS | INDICATION):
995 case (CC_NOTIFY | INDICATION):
996 break;
997 case (CC_REDIR | INDICATION):
998 stat_redir_result(cs, chanp->chan, pc->redir_result);
999 break;
1000 default:
1001 if (chanp->debug & 0x800) {
1002 HiSax_putstatus(chanp->cs, "Ch",
1003 "%d L3->L4 unknown primitiv %#x",
1004 chanp->chan, pr);
1005 }
1006 }
1007 }
1008
1009 static void
1010 dummy_pstack(struct PStack *st, int pr, void *arg) {
1011 printk(KERN_WARNING"call to dummy_pstack pr=%04x arg %lx\n", pr, (long)arg);
1012 }
1013
1014 static int
1015 init_PStack(struct PStack **stp) {
1016 *stp = kmalloc(sizeof(struct PStack), GFP_ATOMIC);
1017 if (!*stp)
1018 return -ENOMEM;
1019 (*stp)->next = NULL;
1020 (*stp)->l1.l1l2 = dummy_pstack;
1021 (*stp)->l1.l1hw = dummy_pstack;
1022 (*stp)->l1.l1tei = dummy_pstack;
1023 (*stp)->l2.l2tei = dummy_pstack;
1024 (*stp)->l2.l2l1 = dummy_pstack;
1025 (*stp)->l2.l2l3 = dummy_pstack;
1026 (*stp)->l3.l3l2 = dummy_pstack;
1027 (*stp)->l3.l3ml3 = dummy_pstack;
1028 (*stp)->l3.l3l4 = dummy_pstack;
1029 (*stp)->lli.l4l3 = dummy_pstack;
1030 (*stp)->ma.layer = dummy_pstack;
1031 return 0;
1032 }
1033
1034 static int
1035 init_d_st(struct Channel *chanp)
1036 {
1037 struct PStack *st;
1038 struct IsdnCardState *cs = chanp->cs;
1039 char tmp[16];
1040 int err;
1041
1042 err = init_PStack(&chanp->d_st);
1043 if (err)
1044 return err;
1045 st = chanp->d_st;
1046 st->next = NULL;
1047 HiSax_addlist(cs, st);
1048 setstack_HiSax(st, cs);
1049 st->l2.sap = 0;
1050 st->l2.tei = -1;
1051 st->l2.flag = 0;
1052 test_and_set_bit(FLG_MOD128, &st->l2.flag);
1053 test_and_set_bit(FLG_LAPD, &st->l2.flag);
1054 test_and_set_bit(FLG_ORIG, &st->l2.flag);
1055 st->l2.maxlen = MAX_DFRAME_LEN;
1056 st->l2.window = 1;
1057 st->l2.T200 = 1000; /* 1000 milliseconds */
1058 st->l2.N200 = 3; /* try 3 times */
1059 st->l2.T203 = 10000; /* 10000 milliseconds */
1060 if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
1061 sprintf(tmp, "DCh%d Q.921 ", chanp->chan);
1062 else
1063 sprintf(tmp, "DCh Q.921 ");
1064 setstack_isdnl2(st, tmp);
1065 setstack_l3dc(st, chanp);
1066 st->lli.userdata = chanp;
1067 st->l3.l3l4 = dchan_l3l4;
1068
1069 return 0;
1070 }
1071
1072 static void
1073 callc_debug(struct FsmInst *fi, char *fmt, ...)
1074 {
1075 va_list args;
1076 struct Channel *chanp = fi->userdata;
1077 char tmp[16];
1078
1079 va_start(args, fmt);
1080 sprintf(tmp, "Ch%d callc ", chanp->chan);
1081 VHiSax_putstatus(chanp->cs, tmp, fmt, args);
1082 va_end(args);
1083 }
1084
1085 static int
1086 init_chan(int chan, struct IsdnCardState *csta)
1087 {
1088 struct Channel *chanp = csta->channel + chan;
1089 int err;
1090
1091 chanp->cs = csta;
1092 chanp->bcs = csta->bcs + chan;
1093 chanp->chan = chan;
1094 chanp->incoming = 0;
1095 chanp->debug = 0;
1096 chanp->Flags = 0;
1097 chanp->leased = 0;
1098 err = init_PStack(&chanp->b_st);
1099 if (err)
1100 return err;
1101 chanp->b_st->l1.delay = DEFAULT_B_DELAY;
1102 chanp->fi.fsm = &callcfsm;
1103 chanp->fi.state = ST_NULL;
1104 chanp->fi.debug = 0;
1105 chanp->fi.userdata = chanp;
1106 chanp->fi.printdebug = callc_debug;
1107 FsmInitTimer(&chanp->fi, &chanp->dial_timer);
1108 FsmInitTimer(&chanp->fi, &chanp->drel_timer);
1109 if (!chan || (test_bit(FLG_TWO_DCHAN, &csta->HW_Flags) && chan < 2)) {
1110 err = init_d_st(chanp);
1111 if (err)
1112 return err;
1113 } else {
1114 chanp->d_st = csta->channel->d_st;
1115 }
1116 chanp->data_open = 0;
1117 return 0;
1118 }
1119
1120 int
1121 CallcNewChan(struct IsdnCardState *csta) {
1122 int i, err;
1123
1124 chancount += 2;
1125 err = init_chan(0, csta);
1126 if (err)
1127 return err;
1128 err = init_chan(1, csta);
1129 if (err)
1130 return err;
1131 printk(KERN_INFO "HiSax: 2 channels added\n");
1132
1133 for (i = 0; i < MAX_WAITING_CALLS; i++) {
1134 err = init_chan(i+2,csta);
1135 if (err)
1136 return err;
1137 }
1138 printk(KERN_INFO "HiSax: MAX_WAITING_CALLS added\n");
1139 if (test_bit(FLG_PTP, &csta->channel->d_st->l2.flag)) {
1140 printk(KERN_INFO "LAYER2 WATCHING ESTABLISH\n");
1141 csta->channel->d_st->lli.l4l3(csta->channel->d_st,
1142 DL_ESTABLISH | REQUEST, NULL);
1143 }
1144 return (0);
1145 }
1146
1147 static void
1148 release_d_st(struct Channel *chanp)
1149 {
1150 struct PStack *st = chanp->d_st;
1151
1152 if (!st)
1153 return;
1154 releasestack_isdnl2(st);
1155 releasestack_isdnl3(st);
1156 HiSax_rmlist(st->l1.hardware, st);
1157 kfree(st);
1158 chanp->d_st = NULL;
1159 }
1160
1161 void
1162 CallcFreeChan(struct IsdnCardState *csta)
1163 {
1164 int i;
1165
1166 for (i = 0; i < 2; i++) {
1167 FsmDelTimer(&csta->channel[i].drel_timer, 74);
1168 FsmDelTimer(&csta->channel[i].dial_timer, 75);
1169 if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags))
1170 release_d_st(csta->channel + i);
1171 if (csta->channel[i].b_st) {
1172 release_b_st(csta->channel + i);
1173 kfree(csta->channel[i].b_st);
1174 csta->channel[i].b_st = NULL;
1175 } else
1176 printk(KERN_WARNING "CallcFreeChan b_st ch%d allready freed\n", i);
1177 if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
1178 release_d_st(csta->channel + i);
1179 } else
1180 csta->channel[i].d_st = NULL;
1181 }
1182 }
1183
1184 static void
1185 lldata_handler(struct PStack *st, int pr, void *arg)
1186 {
1187 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1188 struct sk_buff *skb = arg;
1189
1190 switch (pr) {
1191 case (DL_DATA | INDICATION):
1192 if (chanp->data_open) {
1193 if (chanp->debug & 0x800)
1194 link_debug(chanp, 0, "lldata: %d", skb->len);
1195 chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
1196 } else {
1197 link_debug(chanp, 0, "lldata: channel not open");
1198 dev_kfree_skb(skb);
1199 }
1200 break;
1201 case (DL_ESTABLISH | INDICATION):
1202 case (DL_ESTABLISH | CONFIRM):
1203 FsmEvent(&chanp->fi, EV_BC_EST, NULL);
1204 break;
1205 case (DL_RELEASE | INDICATION):
1206 case (DL_RELEASE | CONFIRM):
1207 FsmEvent(&chanp->fi, EV_BC_REL, NULL);
1208 break;
1209 default:
1210 printk(KERN_WARNING "lldata_handler unknown primitive %#x\n",
1211 pr);
1212 break;
1213 }
1214 }
1215
1216 static void
1217 lltrans_handler(struct PStack *st, int pr, void *arg)
1218 {
1219 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1220 struct sk_buff *skb = arg;
1221
1222 switch (pr) {
1223 case (PH_DATA | INDICATION):
1224 if (chanp->data_open) {
1225 if (chanp->debug & 0x800)
1226 link_debug(chanp, 0, "lltrans: %d", skb->len);
1227 chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
1228 } else {
1229 link_debug(chanp, 0, "lltrans: channel not open");
1230 dev_kfree_skb(skb);
1231 }
1232 break;
1233 case (PH_ACTIVATE | INDICATION):
1234 case (PH_ACTIVATE | CONFIRM):
1235 FsmEvent(&chanp->fi, EV_BC_EST, NULL);
1236 break;
1237 case (PH_DEACTIVATE | INDICATION):
1238 case (PH_DEACTIVATE | CONFIRM):
1239 FsmEvent(&chanp->fi, EV_BC_REL, NULL);
1240 break;
1241 default:
1242 printk(KERN_WARNING "lltrans_handler unknown primitive %#x\n",
1243 pr);
1244 break;
1245 }
1246 }
1247
1248 void
1249 lli_writewakeup(struct PStack *st, int len)
1250 {
1251 struct Channel *chanp = st->lli.userdata;
1252 isdn_ctrl ic;
1253
1254 if (chanp->debug & 0x800)
1255 link_debug(chanp, 0, "llwakeup: %d", len);
1256 ic.driver = chanp->cs->myid;
1257 ic.command = ISDN_STAT_BSENT;
1258 ic.arg = chanp->chan;
1259 ic.parm.length = len;
1260 chanp->cs->iif.statcallb(&ic);
1261 }
1262
1263 static int
1264 init_b_st(struct Channel *chanp, int incoming)
1265 {
1266 struct PStack *st = chanp->b_st;
1267 struct IsdnCardState *cs = chanp->cs;
1268 char tmp[16];
1269
1270 st->l1.hardware = cs;
1271 if (chanp->leased)
1272 st->l1.bc = chanp->chan & 1;
1273 else
1274 st->l1.bc = chanp->proc->para.bchannel - 1;
1275 switch (chanp->l2_active_protocol) {
1276 case (ISDN_PROTO_L2_X75I):
1277 case (ISDN_PROTO_L2_HDLC):
1278 st->l1.mode = L1_MODE_HDLC;
1279 break;
1280 case (ISDN_PROTO_L2_HDLC_56K):
1281 st->l1.mode = L1_MODE_HDLC_56K;
1282 break;
1283 case (ISDN_PROTO_L2_TRANS):
1284 st->l1.mode = L1_MODE_TRANS;
1285 break;
1286 case (ISDN_PROTO_L2_MODEM):
1287 st->l1.mode = L1_MODE_V32;
1288 break;
1289 case (ISDN_PROTO_L2_FAX):
1290 st->l1.mode = L1_MODE_FAX;
1291 break;
1292 }
1293 chanp->bcs->conmsg = NULL;
1294 if (chanp->bcs->BC_SetStack(st, chanp->bcs))
1295 return (-1);
1296 st->l2.flag = 0;
1297 test_and_set_bit(FLG_LAPB, &st->l2.flag);
1298 st->l2.maxlen = MAX_DATA_SIZE;
1299 if (!incoming)
1300 test_and_set_bit(FLG_ORIG, &st->l2.flag);
1301 st->l2.T200 = 1000; /* 1000 milliseconds */
1302 st->l2.window = 7;
1303 st->l2.N200 = 4; /* try 4 times */
1304 st->l2.T203 = 5000; /* 5000 milliseconds */
1305 st->l3.debug = 0;
1306 switch (chanp->l2_active_protocol) {
1307 case (ISDN_PROTO_L2_X75I):
1308 sprintf(tmp, "Ch%d X.75", chanp->chan);
1309 setstack_isdnl2(st, tmp);
1310 setstack_l3bc(st, chanp);
1311 st->l2.l2l3 = lldata_handler;
1312 st->lli.userdata = chanp;
1313 test_and_clear_bit(FLG_LLI_L1WAKEUP, &st->lli.flag);
1314 test_and_set_bit(FLG_LLI_L2WAKEUP, &st->lli.flag);
1315 st->l2.l2m.debug = chanp->debug & 16;
1316 st->l2.debug = chanp->debug & 64;
1317 break;
1318 case (ISDN_PROTO_L2_HDLC):
1319 case (ISDN_PROTO_L2_HDLC_56K):
1320 case (ISDN_PROTO_L2_TRANS):
1321 case (ISDN_PROTO_L2_MODEM):
1322 case (ISDN_PROTO_L2_FAX):
1323 st->l1.l1l2 = lltrans_handler;
1324 st->lli.userdata = chanp;
1325 test_and_set_bit(FLG_LLI_L1WAKEUP, &st->lli.flag);
1326 test_and_clear_bit(FLG_LLI_L2WAKEUP, &st->lli.flag);
1327 setstack_transl2(st);
1328 setstack_l3bc(st, chanp);
1329 break;
1330 }
1331 test_and_set_bit(FLG_START_B, &chanp->Flags);
1332 return (0);
1333 }
1334
1335 static void
1336 leased_l4l3(struct PStack *st, int pr, void *arg)
1337 {
1338 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1339 struct sk_buff *skb = arg;
1340
1341 switch (pr) {
1342 case (DL_DATA | REQUEST):
1343 link_debug(chanp, 0, "leased line d-channel DATA");
1344 dev_kfree_skb(skb);
1345 break;
1346 case (DL_ESTABLISH | REQUEST):
1347 st->l2.l2l1(st, PH_ACTIVATE | REQUEST, NULL);
1348 break;
1349 case (DL_RELEASE | REQUEST):
1350 break;
1351 default:
1352 printk(KERN_WARNING "transd_l4l3 unknown primitive %#x\n",
1353 pr);
1354 break;
1355 }
1356 }
1357
1358 static void
1359 leased_l1l2(struct PStack *st, int pr, void *arg)
1360 {
1361 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1362 struct sk_buff *skb = arg;
1363 int i,event = EV_LEASED_REL;
1364
1365 switch (pr) {
1366 case (PH_DATA | INDICATION):
1367 link_debug(chanp, 0, "leased line d-channel DATA");
1368 dev_kfree_skb(skb);
1369 break;
1370 case (PH_ACTIVATE | INDICATION):
1371 case (PH_ACTIVATE | CONFIRM):
1372 event = EV_LEASED;
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
1392 static void
1393 distr_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
1418 static char tmpbuf[256];
1419
1420 static void
1421 capi_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
1431 static void
1432 lli_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: /* Suspend */
1441 strncpy(chanp->setup.phone, &cm->para[5], cm->para[5] +1);
1442 FsmEvent(&chanp->fi, EV_SUSPEND, cm);
1443 break;
1444 case 5: /* Resume */
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
1456 static void
1457 lli_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 /* Limit the available number of channels for the current card */
1469 /***************************************************************/
1470 static int
1471 set_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; /* disabled */
1485 else
1486 ic.parm.num[0] = 1; /* enabled */
1487 i = cs->iif.statcallb(&ic);
1488 if (i) return(-EINVAL);
1489 if (ii < chanmax)
1490 cs->chanlimit++;
1491 }
1492 return(0);
1493 } /* set_channel_limit */
1494
1495 int
1496 HiSax_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 /* this solution is dirty and may be change, if
1538 * we make a callreference based callmanager */
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): /* set card in leased mode */
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): /* set B-channel test loop */
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): /* set card in PTP mode */
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): /* set card in FIXED TEI mode */
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 ioclt %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 /* protocol specific io commands */
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
1740 int
1741 HiSax_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 /* Must return 0 here, since this is not an error
1769 * but a temporary lack of resources.
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 }
linux-next