?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Do dirty page accounting when removing a page from the page cache
[pv_ops_mirror.git] / drivers / isdn / hisax / callc.c
blob7c56c44f0fd16955be1e7c488bfc862e709f24a1
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 extern int nrcards;
28
29 static int init_b_st(struct Channel *chanp, int incoming);
30 static void release_b_st(struct Channel *chanp);
31
32 static struct Fsm callcfsm;
33 static int chancount;
34
35 /* experimental REJECT after ALERTING for CALLBACK to beat the 4s delay */
36 #define ALERT_REJECT 0
37
38 /* Value to delay the sending of the first B-channel paket after CONNECT
39 * here is no value given by ITU, but experience shows that 300 ms will
40 * work on many networks, if you or your other side is behind local exchanges
41 * a greater value may be recommented. If the delay is to short the first paket
42 * will be lost and autodetect on many comercial routers goes wrong !
43 * You can adjust this value on runtime with
44 * hisaxctrl <id> 2 <value>
45 * value is in milliseconds
46 */
47 #define DEFAULT_B_DELAY 300
48
49 /* Flags for remembering action done in lli */
50
51 #define FLG_START_B 0
52
53 /*
54 * Find card with given driverId
55 */
56 static inline struct IsdnCardState *
57 hisax_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
68 static 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
81 enum {
82 ST_NULL, /* 0 inactive */
83 ST_OUT_DIAL, /* 1 outgoing, SETUP send; awaiting confirm */
84 ST_IN_WAIT_LL, /* 2 incoming call received; wait for LL confirm */
85 ST_IN_ALERT_SENT, /* 3 incoming call received; ALERT send */
86 ST_IN_WAIT_CONN_ACK, /* 4 incoming CONNECT send; awaiting CONN_ACK */
87 ST_WAIT_BCONN, /* 5 CONNECT/CONN_ACK received, awaiting b-channel prot. estbl. */
88 ST_ACTIVE, /* 6 active, b channel prot. established */
89 ST_WAIT_BRELEASE, /* 7 call clear. (initiator), awaiting b channel prot. rel. */
90 ST_WAIT_BREL_DISC, /* 8 call clear. (receiver), DISCONNECT req. received */
91 ST_WAIT_DCOMMAND, /* 9 call clear. (receiver), awaiting DCHANNEL message */
92 ST_WAIT_DRELEASE, /* 10 DISCONNECT sent, awaiting RELEASE */
93 ST_WAIT_D_REL_CNF, /* 11 RELEASE sent, awaiting RELEASE confirm */
94 ST_IN_PROCEED_SEND, /* 12 incoming call, proceeding send */
95 };
96
97
98 #define STATE_COUNT (ST_IN_PROCEED_SEND + 1)
99
100 static 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
117 enum {
118 EV_DIAL, /* 0 */
119 EV_SETUP_CNF, /* 1 */
120 EV_ACCEPTB, /* 2 */
121 EV_DISCONNECT_IND, /* 3 */
122 EV_RELEASE, /* 4 */
123 EV_LEASED, /* 5 */
124 EV_LEASED_REL, /* 6 */
125 EV_SETUP_IND, /* 7 */
126 EV_ACCEPTD, /* 8 */
127 EV_SETUP_CMPL_IND, /* 9 */
128 EV_BC_EST, /* 10 */
129 EV_WRITEBUF, /* 11 */
130 EV_HANGUP, /* 12 */
131 EV_BC_REL, /* 13 */
132 EV_CINF, /* 14 */
133 EV_SUSPEND, /* 15 */
134 EV_RESUME, /* 16 */
135 EV_NOSETUP_RSP, /* 17 */
136 EV_SETUP_ERR, /* 18 */
137 EV_CONNECT_ERR, /* 19 */
138 EV_PROCEED, /* 20 */
139 EV_ALERT, /* 21 */
140 EV_REDIR, /* 22 */
141 };
142
143 #define EVENT_COUNT (EV_REDIR + 1)
144
145 static 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
173 static inline void
174 HL_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
184 static inline void
185 lli_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
205 static inline void
206 lli_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
215 static void
216 lli_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 * Dial out
249 */
250 static void
251 lli_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
263 static void
264 lli_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
281 static void
282 lli_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
299 static void
300 lli_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 * RESUME
324 */
325
326 /* incoming call */
327
328 static void
329 lli_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 * Report incoming calls only once to linklevel, use CallFlags
338 * which is set to 3 with each broadcast message in isdnl1.c
339 * and resetted if a interface answered the STAT_ICALL.
340 */
341 if (1) { /* for only one TEI */
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 * No need to return "unknown" for calls without OAD,
351 * cause that's handled in linklevel now (replaced by '0')
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: /* OK, someone likes this call */
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: /* direct redirect */
365 case 4: /* Proceeding desired */
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: /* Rejecting Call */
375 break;
376 case 3: /* incomplete number */
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: /* OK, nobody likes this call */
381 default: /* statcallb problems */
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
393 static void
394 lli_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
402 static void
403 lli_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
411 static void
412 lli_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
419 static void
420 lli_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
434 static void
435 lli_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 /* Call suspend */
451
452 static void
453 lli_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 /* Call clearing */
461
462 static void
463 lli_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
478 static void
479 lli_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; /* Normal Call Clearing */
489 chanp->d_st->lli.l4l3(chanp->d_st, CC_DISCONNECT | REQUEST,
490 chanp->proc);
491 }
492 }
493
494 static void
495 lli_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; /* Call Rejected */
505 chanp->d_st->lli.l4l3(chanp->d_st, CC_DISCONNECT | REQUEST,
506 chanp->proc);
507 }
508 }
509
510 static void
511 lli_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
526 static void
527 lli_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; /* Call Rejected */
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
547 static void
548 lli_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
557 static void
558 lli_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
569 static void
570 lli_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
578 static void
579 lli_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
589 static void
590 lli_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
602 static void
603 lli_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
613 static void
614 lli_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
622 static void
623 lli_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
633 static void
634 lli_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
643 static void
644 lli_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
657 static void
658 lli_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
666 static void
667 lli_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 /* processing charge info */
679 static void
680 lli_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 /* error procedures */
693
694 static void
695 lli_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
704 static void
705 lli_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
715 static void
716 lli_error(struct FsmInst *fi, int event, void *arg)
717 {
718 FsmChangeState(fi, ST_WAIT_DRELEASE);
719 }
720
721 static void
722 lli_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
738 static void
739 lli_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
747 static void
748 lli_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
758 static void
759 lli_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 /* *INDENT-OFF* */
769 static 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 /* ETS 300-104 16.1 */
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 /* *INDENT-ON* */
836
837 #define FNCOUNT (sizeof(fnlist)/sizeof(struct FsmNode))
838
839 int __init
840 CallcNew(void)
841 {
842 callcfsm.state_count = STATE_COUNT;
843 callcfsm.event_count = EVENT_COUNT;
844 callcfsm.strEvent = strEvent;
845 callcfsm.strState = strState;
846 return FsmNew(&callcfsm, fnlist, FNCOUNT);
847 }
848
849 void
850 CallcFree(void)
851 {
852 FsmFree(&callcfsm);
853 }
854
855 static void
856 release_b_st(struct Channel *chanp)
857 {
858 struct PStack *st = chanp->b_st;
859
860 if(test_and_clear_bit(FLG_START_B, &chanp->Flags)) {
861 chanp->bcs->BC_Close(chanp->bcs);
862 switch (chanp->l2_active_protocol) {
863 case (ISDN_PROTO_L2_X75I):
864 releasestack_isdnl2(st);
865 break;
866 case (ISDN_PROTO_L2_HDLC):
867 case (ISDN_PROTO_L2_HDLC_56K):
868 case (ISDN_PROTO_L2_TRANS):
869 case (ISDN_PROTO_L2_MODEM):
870 case (ISDN_PROTO_L2_FAX):
871 releasestack_transl2(st);
872 break;
873 }
874 }
875 }
876
877 static struct Channel
878 *selectfreechannel(struct PStack *st, int bch)
879 {
880 struct IsdnCardState *cs = st->l1.hardware;
881 struct Channel *chanp = st->lli.userdata;
882 int i;
883
884 if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
885 i=1;
886 else
887 i=0;
888
889 if (!bch) {
890 i = 2; /* virtual channel */
891 chanp += 2;
892 }
893
894 while (i < ((bch) ? cs->chanlimit : (2 + MAX_WAITING_CALLS))) {
895 if (chanp->fi.state == ST_NULL)
896 return (chanp);
897 chanp++;
898 i++;
899 }
900
901 if (bch) /* number of channels is limited */ {
902 i = 2; /* virtual channel */
903 chanp = st->lli.userdata;
904 chanp += i;
905 while (i < (2 + MAX_WAITING_CALLS)) {
906 if (chanp->fi.state == ST_NULL)
907 return (chanp);
908 chanp++;
909 i++;
910 }
911 }
912 return (NULL);
913 }
914
915 static void stat_redir_result(struct IsdnCardState *cs, int chan, ulong result)
916 { isdn_ctrl ic;
917
918 ic.driver = cs->myid;
919 ic.command = ISDN_STAT_REDIR;
920 ic.arg = chan;
921 ic.parm.num[0] = result;
922 cs->iif.statcallb(&ic);
923 } /* stat_redir_result */
924
925 static void
926 dchan_l3l4(struct PStack *st, int pr, void *arg)
927 {
928 struct l3_process *pc = arg;
929 struct IsdnCardState *cs = st->l1.hardware;
930 struct Channel *chanp;
931
932 if(!pc)
933 return;
934
935 if (pr == (CC_SETUP | INDICATION)) {
936 if (!(chanp = selectfreechannel(pc->st, pc->para.bchannel))) {
937 pc->para.cause = 0x11; /* User busy */
938 pc->st->lli.l4l3(pc->st, CC_REJECT | REQUEST, pc);
939 } else {
940 chanp->proc = pc;
941 pc->chan = chanp;
942 FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
943 }
944 return;
945 }
946 if (!(chanp = pc->chan))
947 return;
948
949 switch (pr) {
950 case (CC_MORE_INFO | INDICATION):
951 FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
952 break;
953 case (CC_DISCONNECT | INDICATION):
954 FsmEvent(&chanp->fi, EV_DISCONNECT_IND, NULL);
955 break;
956 case (CC_RELEASE | CONFIRM):
957 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
958 break;
959 case (CC_SUSPEND | CONFIRM):
960 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
961 break;
962 case (CC_RESUME | CONFIRM):
963 FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
964 break;
965 case (CC_RESUME_ERR):
966 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
967 break;
968 case (CC_RELEASE | INDICATION):
969 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
970 break;
971 case (CC_SETUP_COMPL | INDICATION):
972 FsmEvent(&chanp->fi, EV_SETUP_CMPL_IND, NULL);
973 break;
974 case (CC_SETUP | CONFIRM):
975 FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
976 break;
977 case (CC_CHARGE | INDICATION):
978 FsmEvent(&chanp->fi, EV_CINF, NULL);
979 break;
980 case (CC_NOSETUP_RSP):
981 FsmEvent(&chanp->fi, EV_NOSETUP_RSP, NULL);
982 break;
983 case (CC_SETUP_ERR):
984 FsmEvent(&chanp->fi, EV_SETUP_ERR, NULL);
985 break;
986 case (CC_CONNECT_ERR):
987 FsmEvent(&chanp->fi, EV_CONNECT_ERR, NULL);
988 break;
989 case (CC_RELEASE_ERR):
990 FsmEvent(&chanp->fi, EV_RELEASE, NULL);
991 break;
992 case (CC_PROCEED_SEND | INDICATION):
993 case (CC_PROCEEDING | INDICATION):
994 case (CC_ALERTING | INDICATION):
995 case (CC_PROGRESS | INDICATION):
996 case (CC_NOTIFY | INDICATION):
997 break;
998 case (CC_REDIR | INDICATION):
999 stat_redir_result(cs, chanp->chan, pc->redir_result);
1000 break;
1001 default:
1002 if (chanp->debug & 0x800) {
1003 HiSax_putstatus(chanp->cs, "Ch",
1004 "%d L3->L4 unknown primitiv %#x",
1005 chanp->chan, pr);
1006 }
1007 }
1008 }
1009
1010 static void
1011 dummy_pstack(struct PStack *st, int pr, void *arg) {
1012 printk(KERN_WARNING"call to dummy_pstack pr=%04x arg %lx\n", pr, (long)arg);
1013 }
1014
1015 static int
1016 init_PStack(struct PStack **stp) {
1017 *stp = kmalloc(sizeof(struct PStack), GFP_ATOMIC);
1018 if (!*stp)
1019 return -ENOMEM;
1020 (*stp)->next = NULL;
1021 (*stp)->l1.l1l2 = dummy_pstack;
1022 (*stp)->l1.l1hw = dummy_pstack;
1023 (*stp)->l1.l1tei = dummy_pstack;
1024 (*stp)->l2.l2tei = dummy_pstack;
1025 (*stp)->l2.l2l1 = dummy_pstack;
1026 (*stp)->l2.l2l3 = dummy_pstack;
1027 (*stp)->l3.l3l2 = dummy_pstack;
1028 (*stp)->l3.l3ml3 = dummy_pstack;
1029 (*stp)->l3.l3l4 = dummy_pstack;
1030 (*stp)->lli.l4l3 = dummy_pstack;
1031 (*stp)->ma.layer = dummy_pstack;
1032 return 0;
1033 }
1034
1035 static int
1036 init_d_st(struct Channel *chanp)
1037 {
1038 struct PStack *st;
1039 struct IsdnCardState *cs = chanp->cs;
1040 char tmp[16];
1041 int err;
1042
1043 err = init_PStack(&chanp->d_st);
1044 if (err)
1045 return err;
1046 st = chanp->d_st;
1047 st->next = NULL;
1048 HiSax_addlist(cs, st);
1049 setstack_HiSax(st, cs);
1050 st->l2.sap = 0;
1051 st->l2.tei = -1;
1052 st->l2.flag = 0;
1053 test_and_set_bit(FLG_MOD128, &st->l2.flag);
1054 test_and_set_bit(FLG_LAPD, &st->l2.flag);
1055 test_and_set_bit(FLG_ORIG, &st->l2.flag);
1056 st->l2.maxlen = MAX_DFRAME_LEN;
1057 st->l2.window = 1;
1058 st->l2.T200 = 1000; /* 1000 milliseconds */
1059 st->l2.N200 = 3; /* try 3 times */
1060 st->l2.T203 = 10000; /* 10000 milliseconds */
1061 if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
1062 sprintf(tmp, "DCh%d Q.921 ", chanp->chan);
1063 else
1064 sprintf(tmp, "DCh Q.921 ");
1065 setstack_isdnl2(st, tmp);
1066 setstack_l3dc(st, chanp);
1067 st->lli.userdata = chanp;
1068 st->l3.l3l4 = dchan_l3l4;
1069
1070 return 0;
1071 }
1072
1073 static void
1074 callc_debug(struct FsmInst *fi, char *fmt, ...)
1075 {
1076 va_list args;
1077 struct Channel *chanp = fi->userdata;
1078 char tmp[16];
1079
1080 va_start(args, fmt);
1081 sprintf(tmp, "Ch%d callc ", chanp->chan);
1082 VHiSax_putstatus(chanp->cs, tmp, fmt, args);
1083 va_end(args);
1084 }
1085
1086 static int
1087 init_chan(int chan, struct IsdnCardState *csta)
1088 {
1089 struct Channel *chanp = csta->channel + chan;
1090 int err;
1091
1092 chanp->cs = csta;
1093 chanp->bcs = csta->bcs + chan;
1094 chanp->chan = chan;
1095 chanp->incoming = 0;
1096 chanp->debug = 0;
1097 chanp->Flags = 0;
1098 chanp->leased = 0;
1099 err = init_PStack(&chanp->b_st);
1100 if (err)
1101 return err;
1102 chanp->b_st->l1.delay = DEFAULT_B_DELAY;
1103 chanp->fi.fsm = &callcfsm;
1104 chanp->fi.state = ST_NULL;
1105 chanp->fi.debug = 0;
1106 chanp->fi.userdata = chanp;
1107 chanp->fi.printdebug = callc_debug;
1108 FsmInitTimer(&chanp->fi, &chanp->dial_timer);
1109 FsmInitTimer(&chanp->fi, &chanp->drel_timer);
1110 if (!chan || (test_bit(FLG_TWO_DCHAN, &csta->HW_Flags) && chan < 2)) {
1111 err = init_d_st(chanp);
1112 if (err)
1113 return err;
1114 } else {
1115 chanp->d_st = csta->channel->d_st;
1116 }
1117 chanp->data_open = 0;
1118 return 0;
1119 }
1120
1121 int
1122 CallcNewChan(struct IsdnCardState *csta) {
1123 int i, err;
1124
1125 chancount += 2;
1126 err = init_chan(0, csta);
1127 if (err)
1128 return err;
1129 err = init_chan(1, csta);
1130 if (err)
1131 return err;
1132 printk(KERN_INFO "HiSax: 2 channels added\n");
1133
1134 for (i = 0; i < MAX_WAITING_CALLS; i++) {
1135 err = init_chan(i+2,csta);
1136 if (err)
1137 return err;
1138 }
1139 printk(KERN_INFO "HiSax: MAX_WAITING_CALLS added\n");
1140 if (test_bit(FLG_PTP, &csta->channel->d_st->l2.flag)) {
1141 printk(KERN_INFO "LAYER2 WATCHING ESTABLISH\n");
1142 csta->channel->d_st->lli.l4l3(csta->channel->d_st,
1143 DL_ESTABLISH | REQUEST, NULL);
1144 }
1145 return (0);
1146 }
1147
1148 static void
1149 release_d_st(struct Channel *chanp)
1150 {
1151 struct PStack *st = chanp->d_st;
1152
1153 if (!st)
1154 return;
1155 releasestack_isdnl2(st);
1156 releasestack_isdnl3(st);
1157 HiSax_rmlist(st->l1.hardware, st);
1158 kfree(st);
1159 chanp->d_st = NULL;
1160 }
1161
1162 void
1163 CallcFreeChan(struct IsdnCardState *csta)
1164 {
1165 int i;
1166
1167 for (i = 0; i < 2; i++) {
1168 FsmDelTimer(&csta->channel[i].drel_timer, 74);
1169 FsmDelTimer(&csta->channel[i].dial_timer, 75);
1170 if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags))
1171 release_d_st(csta->channel + i);
1172 if (csta->channel[i].b_st) {
1173 release_b_st(csta->channel + i);
1174 kfree(csta->channel[i].b_st);
1175 csta->channel[i].b_st = NULL;
1176 } else
1177 printk(KERN_WARNING "CallcFreeChan b_st ch%d allready freed\n", i);
1178 if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
1179 release_d_st(csta->channel + i);
1180 } else
1181 csta->channel[i].d_st = NULL;
1182 }
1183 }
1184
1185 static void
1186 lldata_handler(struct PStack *st, int pr, void *arg)
1187 {
1188 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1189 struct sk_buff *skb = arg;
1190
1191 switch (pr) {
1192 case (DL_DATA | INDICATION):
1193 if (chanp->data_open) {
1194 if (chanp->debug & 0x800)
1195 link_debug(chanp, 0, "lldata: %d", skb->len);
1196 chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
1197 } else {
1198 link_debug(chanp, 0, "lldata: channel not open");
1199 dev_kfree_skb(skb);
1200 }
1201 break;
1202 case (DL_ESTABLISH | INDICATION):
1203 case (DL_ESTABLISH | CONFIRM):
1204 FsmEvent(&chanp->fi, EV_BC_EST, NULL);
1205 break;
1206 case (DL_RELEASE | INDICATION):
1207 case (DL_RELEASE | CONFIRM):
1208 FsmEvent(&chanp->fi, EV_BC_REL, NULL);
1209 break;
1210 default:
1211 printk(KERN_WARNING "lldata_handler unknown primitive %#x\n",
1212 pr);
1213 break;
1214 }
1215 }
1216
1217 static void
1218 lltrans_handler(struct PStack *st, int pr, void *arg)
1219 {
1220 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1221 struct sk_buff *skb = arg;
1222
1223 switch (pr) {
1224 case (PH_DATA | INDICATION):
1225 if (chanp->data_open) {
1226 if (chanp->debug & 0x800)
1227 link_debug(chanp, 0, "lltrans: %d", skb->len);
1228 chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
1229 } else {
1230 link_debug(chanp, 0, "lltrans: channel not open");
1231 dev_kfree_skb(skb);
1232 }
1233 break;
1234 case (PH_ACTIVATE | INDICATION):
1235 case (PH_ACTIVATE | CONFIRM):
1236 FsmEvent(&chanp->fi, EV_BC_EST, NULL);
1237 break;
1238 case (PH_DEACTIVATE | INDICATION):
1239 case (PH_DEACTIVATE | CONFIRM):
1240 FsmEvent(&chanp->fi, EV_BC_REL, NULL);
1241 break;
1242 default:
1243 printk(KERN_WARNING "lltrans_handler unknown primitive %#x\n",
1244 pr);
1245 break;
1246 }
1247 }
1248
1249 void
1250 lli_writewakeup(struct PStack *st, int len)
1251 {
1252 struct Channel *chanp = st->lli.userdata;
1253 isdn_ctrl ic;
1254
1255 if (chanp->debug & 0x800)
1256 link_debug(chanp, 0, "llwakeup: %d", len);
1257 ic.driver = chanp->cs->myid;
1258 ic.command = ISDN_STAT_BSENT;
1259 ic.arg = chanp->chan;
1260 ic.parm.length = len;
1261 chanp->cs->iif.statcallb(&ic);
1262 }
1263
1264 static int
1265 init_b_st(struct Channel *chanp, int incoming)
1266 {
1267 struct PStack *st = chanp->b_st;
1268 struct IsdnCardState *cs = chanp->cs;
1269 char tmp[16];
1270
1271 st->l1.hardware = cs;
1272 if (chanp->leased)
1273 st->l1.bc = chanp->chan & 1;
1274 else
1275 st->l1.bc = chanp->proc->para.bchannel - 1;
1276 switch (chanp->l2_active_protocol) {
1277 case (ISDN_PROTO_L2_X75I):
1278 case (ISDN_PROTO_L2_HDLC):
1279 st->l1.mode = L1_MODE_HDLC;
1280 break;
1281 case (ISDN_PROTO_L2_HDLC_56K):
1282 st->l1.mode = L1_MODE_HDLC_56K;
1283 break;
1284 case (ISDN_PROTO_L2_TRANS):
1285 st->l1.mode = L1_MODE_TRANS;
1286 break;
1287 case (ISDN_PROTO_L2_MODEM):
1288 st->l1.mode = L1_MODE_V32;
1289 break;
1290 case (ISDN_PROTO_L2_FAX):
1291 st->l1.mode = L1_MODE_FAX;
1292 break;
1293 }
1294 chanp->bcs->conmsg = NULL;
1295 if (chanp->bcs->BC_SetStack(st, chanp->bcs))
1296 return (-1);
1297 st->l2.flag = 0;
1298 test_and_set_bit(FLG_LAPB, &st->l2.flag);
1299 st->l2.maxlen = MAX_DATA_SIZE;
1300 if (!incoming)
1301 test_and_set_bit(FLG_ORIG, &st->l2.flag);
1302 st->l2.T200 = 1000; /* 1000 milliseconds */
1303 st->l2.window = 7;
1304 st->l2.N200 = 4; /* try 4 times */
1305 st->l2.T203 = 5000; /* 5000 milliseconds */
1306 st->l3.debug = 0;
1307 switch (chanp->l2_active_protocol) {
1308 case (ISDN_PROTO_L2_X75I):
1309 sprintf(tmp, "Ch%d X.75", chanp->chan);
1310 setstack_isdnl2(st, tmp);
1311 setstack_l3bc(st, chanp);
1312 st->l2.l2l3 = lldata_handler;
1313 st->lli.userdata = chanp;
1314 test_and_clear_bit(FLG_LLI_L1WAKEUP, &st->lli.flag);
1315 test_and_set_bit(FLG_LLI_L2WAKEUP, &st->lli.flag);
1316 st->l2.l2m.debug = chanp->debug & 16;
1317 st->l2.debug = chanp->debug & 64;
1318 break;
1319 case (ISDN_PROTO_L2_HDLC):
1320 case (ISDN_PROTO_L2_HDLC_56K):
1321 case (ISDN_PROTO_L2_TRANS):
1322 case (ISDN_PROTO_L2_MODEM):
1323 case (ISDN_PROTO_L2_FAX):
1324 st->l1.l1l2 = lltrans_handler;
1325 st->lli.userdata = chanp;
1326 test_and_set_bit(FLG_LLI_L1WAKEUP, &st->lli.flag);
1327 test_and_clear_bit(FLG_LLI_L2WAKEUP, &st->lli.flag);
1328 setstack_transl2(st);
1329 setstack_l3bc(st, chanp);
1330 break;
1331 }
1332 test_and_set_bit(FLG_START_B, &chanp->Flags);
1333 return (0);
1334 }
1335
1336 static void
1337 leased_l4l3(struct PStack *st, int pr, void *arg)
1338 {
1339 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1340 struct sk_buff *skb = arg;
1341
1342 switch (pr) {
1343 case (DL_DATA | REQUEST):
1344 link_debug(chanp, 0, "leased line d-channel DATA");
1345 dev_kfree_skb(skb);
1346 break;
1347 case (DL_ESTABLISH | REQUEST):
1348 st->l2.l2l1(st, PH_ACTIVATE | REQUEST, NULL);
1349 break;
1350 case (DL_RELEASE | REQUEST):
1351 break;
1352 default:
1353 printk(KERN_WARNING "transd_l4l3 unknown primitive %#x\n",
1354 pr);
1355 break;
1356 }
1357 }
1358
1359 static void
1360 leased_l1l2(struct PStack *st, int pr, void *arg)
1361 {
1362 struct Channel *chanp = (struct Channel *) st->lli.userdata;
1363 struct sk_buff *skb = arg;
1364 int i,event = EV_LEASED_REL;
1365
1366 switch (pr) {
1367 case (PH_DATA | INDICATION):
1368 link_debug(chanp, 0, "leased line d-channel DATA");
1369 dev_kfree_skb(skb);
1370 break;
1371 case (PH_ACTIVATE | INDICATION):
1372 case (PH_ACTIVATE | CONFIRM):
1373 event = EV_LEASED;
1374 case (PH_DEACTIVATE | INDICATION):
1375 case (PH_DEACTIVATE | CONFIRM):
1376 if (test_bit(FLG_TWO_DCHAN, &chanp->cs->HW_Flags))
1377 i = 1;
1378 else
1379 i = 0;
1380 while (i < 2) {
1381 FsmEvent(&chanp->fi, event, NULL);
1382 chanp++;
1383 i++;
1384 }
1385 break;
1386 default:
1387 printk(KERN_WARNING
1388 "transd_l1l2 unknown primitive %#x\n", pr);
1389 break;
1390 }
1391 }
1392
1393 static void
1394 distr_debug(struct IsdnCardState *csta, int debugflags)
1395 {
1396 int i;
1397 struct Channel *chanp = csta->channel;
1398
1399 for (i = 0; i < (2 + MAX_WAITING_CALLS) ; i++) {
1400 chanp[i].debug = debugflags;
1401 chanp[i].fi.debug = debugflags & 2;
1402 chanp[i].d_st->l2.l2m.debug = debugflags & 8;
1403 chanp[i].b_st->l2.l2m.debug = debugflags & 0x10;
1404 chanp[i].d_st->l2.debug = debugflags & 0x20;
1405 chanp[i].b_st->l2.debug = debugflags & 0x40;
1406 chanp[i].d_st->l3.l3m.debug = debugflags & 0x80;
1407 chanp[i].b_st->l3.l3m.debug = debugflags & 0x100;
1408 chanp[i].b_st->ma.tei_m.debug = debugflags & 0x200;
1409 chanp[i].b_st->ma.debug = debugflags & 0x200;
1410 chanp[i].d_st->l1.l1m.debug = debugflags & 0x1000;
1411 chanp[i].b_st->l1.l1m.debug = debugflags & 0x2000;
1412 }
1413 if (debugflags & 4)
1414 csta->debug |= DEB_DLOG_HEX;
1415 else
1416 csta->debug &= ~DEB_DLOG_HEX;
1417 }
1418
1419 static char tmpbuf[256];
1420
1421 static void
1422 capi_debug(struct Channel *chanp, capi_msg *cm)
1423 {
1424 char *t = tmpbuf;
1425
1426 t += QuickHex(t, (u_char *)cm, (cm->Length>50)? 50: cm->Length);
1427 t--;
1428 *t= 0;
1429 HiSax_putstatus(chanp->cs, "Ch", "%d CAPIMSG %s", chanp->chan, tmpbuf);
1430 }
1431
1432 static void
1433 lli_got_fac_req(struct Channel *chanp, capi_msg *cm) {
1434 if ((cm->para[0] != 3) || (cm->para[1] != 0))
1435 return;
1436 if (cm->para[2]<3)
1437 return;
1438 if (cm->para[4] != 0)
1439 return;
1440 switch(cm->para[3]) {
1441 case 4: /* Suspend */
1442 strncpy(chanp->setup.phone, &cm->para[5], cm->para[5] +1);
1443 FsmEvent(&chanp->fi, EV_SUSPEND, cm);
1444 break;
1445 case 5: /* Resume */
1446 strncpy(chanp->setup.phone, &cm->para[5], cm->para[5] +1);
1447 if (chanp->fi.state == ST_NULL) {
1448 FsmEvent(&chanp->fi, EV_RESUME, cm);
1449 } else {
1450 FsmDelTimer(&chanp->dial_timer, 72);
1451 FsmAddTimer(&chanp->dial_timer, 80, EV_RESUME, cm, 73);
1452 }
1453 break;
1454 }
1455 }
1456
1457 static void
1458 lli_got_manufacturer(struct Channel *chanp, struct IsdnCardState *cs, capi_msg *cm) {
1459 if ((cs->typ == ISDN_CTYPE_ELSA) || (cs->typ == ISDN_CTYPE_ELSA_PNP) ||
1460 (cs->typ == ISDN_CTYPE_ELSA_PCI)) {
1461 if (cs->hw.elsa.MFlag) {
1462 cs->cardmsg(cs, CARD_AUX_IND, cm->para);
1463 }
1464 }
1465 }
1466
1467
1468 /***************************************************************/
1469 /* Limit the available number of channels for the current card */
1470 /***************************************************************/
1471 static int
1472 set_channel_limit(struct IsdnCardState *cs, int chanmax)
1473 {
1474 isdn_ctrl ic;
1475 int i, ii;
1476
1477 if ((chanmax < 0) || (chanmax > 2))
1478 return(-EINVAL);
1479 cs->chanlimit = 0;
1480 for (ii = 0; ii < 2; ii++) {
1481 ic.driver = cs->myid;
1482 ic.command = ISDN_STAT_DISCH;
1483 ic.arg = ii;
1484 if (ii >= chanmax)
1485 ic.parm.num[0] = 0; /* disabled */
1486 else
1487 ic.parm.num[0] = 1; /* enabled */
1488 i = cs->iif.statcallb(&ic);
1489 if (i) return(-EINVAL);
1490 if (ii < chanmax)
1491 cs->chanlimit++;
1492 }
1493 return(0);
1494 } /* set_channel_limit */
1495
1496 int
1497 HiSax_command(isdn_ctrl * ic)
1498 {
1499 struct IsdnCardState *csta = hisax_findcard(ic->driver);
1500 struct PStack *st;
1501 struct Channel *chanp;
1502 int i;
1503 u_int num;
1504
1505 if (!csta) {
1506 printk(KERN_ERR
1507 "HiSax: if_command %d called with invalid driverId %d!\n",
1508 ic->command, ic->driver);
1509 return -ENODEV;
1510 }
1511 switch (ic->command) {
1512 case (ISDN_CMD_SETEAZ):
1513 chanp = csta->channel + ic->arg;
1514 break;
1515 case (ISDN_CMD_SETL2):
1516 chanp = csta->channel + (ic->arg & 0xff);
1517 if (chanp->debug & 1)
1518 link_debug(chanp, 1, "SETL2 card %d %ld",
1519 csta->cardnr + 1, ic->arg >> 8);
1520 chanp->l2_protocol = ic->arg >> 8;
1521 break;
1522 case (ISDN_CMD_SETL3):
1523 chanp = csta->channel + (ic->arg & 0xff);
1524 if (chanp->debug & 1)
1525 link_debug(chanp, 1, "SETL3 card %d %ld",
1526 csta->cardnr + 1, ic->arg >> 8);
1527 chanp->l3_protocol = ic->arg >> 8;
1528 break;
1529 case (ISDN_CMD_DIAL):
1530 chanp = csta->channel + (ic->arg & 0xff);
1531 if (chanp->debug & 1)
1532 link_debug(chanp, 1, "DIAL %s -> %s (%d,%d)",
1533 ic->parm.setup.eazmsn, ic->parm.setup.phone,
1534 ic->parm.setup.si1, ic->parm.setup.si2);
1535 memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
1536 if (!strcmp(chanp->setup.eazmsn, "0"))
1537 chanp->setup.eazmsn[0] = '\0';
1538 /* this solution is dirty and may be change, if
1539 * we make a callreference based callmanager */
1540 if (chanp->fi.state == ST_NULL) {
1541 FsmEvent(&chanp->fi, EV_DIAL, NULL);
1542 } else {
1543 FsmDelTimer(&chanp->dial_timer, 70);
1544 FsmAddTimer(&chanp->dial_timer, 50, EV_DIAL, NULL, 71);
1545 }
1546 break;
1547 case (ISDN_CMD_ACCEPTB):
1548 chanp = csta->channel + ic->arg;
1549 if (chanp->debug & 1)
1550 link_debug(chanp, 1, "ACCEPTB");
1551 FsmEvent(&chanp->fi, EV_ACCEPTB, NULL);
1552 break;
1553 case (ISDN_CMD_ACCEPTD):
1554 chanp = csta->channel + ic->arg;
1555 memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
1556 if (chanp->debug & 1)
1557 link_debug(chanp, 1, "ACCEPTD");
1558 FsmEvent(&chanp->fi, EV_ACCEPTD, NULL);
1559 break;
1560 case (ISDN_CMD_HANGUP):
1561 chanp = csta->channel + ic->arg;
1562 if (chanp->debug & 1)
1563 link_debug(chanp, 1, "HANGUP");
1564 FsmEvent(&chanp->fi, EV_HANGUP, NULL);
1565 break;
1566 case (CAPI_PUT_MESSAGE):
1567 chanp = csta->channel + ic->arg;
1568 if (chanp->debug & 1)
1569 capi_debug(chanp, &ic->parm.cmsg);
1570 if (ic->parm.cmsg.Length < 8)
1571 break;
1572 switch(ic->parm.cmsg.Command) {
1573 case CAPI_FACILITY:
1574 if (ic->parm.cmsg.Subcommand == CAPI_REQ)
1575 lli_got_fac_req(chanp, &ic->parm.cmsg);
1576 break;
1577 case CAPI_MANUFACTURER:
1578 if (ic->parm.cmsg.Subcommand == CAPI_REQ)
1579 lli_got_manufacturer(chanp, csta, &ic->parm.cmsg);
1580 break;
1581 default:
1582 break;
1583 }
1584 break;
1585 case (ISDN_CMD_IOCTL):
1586 switch (ic->arg) {
1587 case (0):
1588 num = *(unsigned int *) ic->parm.num;
1589 HiSax_reportcard(csta->cardnr, num);
1590 break;
1591 case (1):
1592 num = *(unsigned int *) ic->parm.num;
1593 distr_debug(csta, num);
1594 printk(KERN_DEBUG "HiSax: debugging flags card %d set to %x\n",
1595 csta->cardnr + 1, num);
1596 HiSax_putstatus(csta, "debugging flags ",
1597 "card %d set to %x", csta->cardnr + 1, num);
1598 break;
1599 case (2):
1600 num = *(unsigned int *) ic->parm.num;
1601 csta->channel[0].b_st->l1.delay = num;
1602 csta->channel[1].b_st->l1.delay = num;
1603 HiSax_putstatus(csta, "delay ", "card %d set to %d ms",
1604 csta->cardnr + 1, num);
1605 printk(KERN_DEBUG "HiSax: delay card %d set to %d ms\n",
1606 csta->cardnr + 1, num);
1607 break;
1608 case (5): /* set card in leased mode */
1609 num = *(unsigned int *) ic->parm.num;
1610 if ((num <1) || (num > 2)) {
1611 HiSax_putstatus(csta, "Set LEASED ",
1612 "wrong channel %d", num);
1613 printk(KERN_WARNING "HiSax: Set LEASED wrong channel %d\n",
1614 num);
1615 } else {
1616 num--;
1617 chanp = csta->channel +num;
1618 chanp->leased = 1;
1619 HiSax_putstatus(csta, "Card",
1620 "%d channel %d set leased mode\n",
1621 csta->cardnr + 1, num + 1);
1622 chanp->d_st->l1.l1l2 = leased_l1l2;
1623 chanp->d_st->lli.l4l3 = leased_l4l3;
1624 chanp->d_st->lli.l4l3(chanp->d_st,
1625 DL_ESTABLISH | REQUEST, NULL);
1626 }
1627 break;
1628 case (6): /* set B-channel test loop */
1629 num = *(unsigned int *) ic->parm.num;
1630 if (csta->stlist)
1631 csta->stlist->l2.l2l1(csta->stlist,
1632 PH_TESTLOOP | REQUEST, (void *) (long)num);
1633 break;
1634 case (7): /* set card in PTP mode */
1635 num = *(unsigned int *) ic->parm.num;
1636 if (test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
1637 printk(KERN_ERR "HiSax PTP mode only with one TEI possible\n");
1638 } else if (num) {
1639 test_and_set_bit(FLG_PTP, &csta->channel[0].d_st->l2.flag);
1640 test_and_set_bit(FLG_FIXED_TEI, &csta->channel[0].d_st->l2.flag);
1641 csta->channel[0].d_st->l2.tei = 0;
1642 HiSax_putstatus(csta, "set card ", "in PTP mode");
1643 printk(KERN_DEBUG "HiSax: set card in PTP mode\n");
1644 printk(KERN_INFO "LAYER2 WATCHING ESTABLISH\n");
1645 csta->channel[0].d_st->lli.l4l3(csta->channel[0].d_st,
1646 DL_ESTABLISH | REQUEST, NULL);
1647 } else {
1648 test_and_clear_bit(FLG_PTP, &csta->channel[0].d_st->l2.flag);
1649 test_and_clear_bit(FLG_FIXED_TEI, &csta->channel[0].d_st->l2.flag);
1650 HiSax_putstatus(csta, "set card ", "in PTMP mode");
1651 printk(KERN_DEBUG "HiSax: set card in PTMP mode\n");
1652 }
1653 break;
1654 case (8): /* set card in FIXED TEI mode */
1655 num = *(unsigned int *) ic->parm.num;
1656 chanp = csta->channel + (num & 1);
1657 num = num >>1;
1658 if (num == 127) {
1659 test_and_clear_bit(FLG_FIXED_TEI, &chanp->d_st->l2.flag);
1660 chanp->d_st->l2.tei = -1;
1661 HiSax_putstatus(csta, "set card ", "in VAR TEI mode");
1662 printk(KERN_DEBUG "HiSax: set card in VAR TEI mode\n");
1663 } else {
1664 test_and_set_bit(FLG_FIXED_TEI, &chanp->d_st->l2.flag);
1665 chanp->d_st->l2.tei = num;
1666 HiSax_putstatus(csta, "set card ", "in FIXED TEI (%d) mode", num);
1667 printk(KERN_DEBUG "HiSax: set card in FIXED TEI (%d) mode\n",
1668 num);
1669 }
1670 chanp->d_st->lli.l4l3(chanp->d_st,
1671 DL_ESTABLISH | REQUEST, NULL);
1672 break;
1673 case (11):
1674 num = csta->debug & DEB_DLOG_HEX;
1675 csta->debug = *(unsigned int *) ic->parm.num;
1676 csta->debug |= num;
1677 HiSax_putstatus(cards[0].cs, "l1 debugging ",
1678 "flags card %d set to %x",
1679 csta->cardnr + 1, csta->debug);
1680 printk(KERN_DEBUG "HiSax: l1 debugging flags card %d set to %x\n",
1681 csta->cardnr + 1, csta->debug);
1682 break;
1683 case (13):
1684 csta->channel[0].d_st->l3.debug = *(unsigned int *) ic->parm.num;
1685 csta->channel[1].d_st->l3.debug = *(unsigned int *) ic->parm.num;
1686 HiSax_putstatus(cards[0].cs, "l3 debugging ",
1687 "flags card %d set to %x\n", csta->cardnr + 1,
1688 *(unsigned int *) ic->parm.num);
1689 printk(KERN_DEBUG "HiSax: l3 debugging flags card %d set to %x\n",
1690 csta->cardnr + 1, *(unsigned int *) ic->parm.num);
1691 break;
1692 case (10):
1693 i = *(unsigned int *) ic->parm.num;
1694 return(set_channel_limit(csta, i));
1695 default:
1696 if (csta->auxcmd)
1697 return(csta->auxcmd(csta, ic));
1698 printk(KERN_DEBUG "HiSax: invalid ioclt %d\n",
1699 (int) ic->arg);
1700 return (-EINVAL);
1701 }
1702 break;
1703
1704 case (ISDN_CMD_PROCEED):
1705 chanp = csta->channel + ic->arg;
1706 if (chanp->debug & 1)
1707 link_debug(chanp, 1, "PROCEED");
1708 FsmEvent(&chanp->fi, EV_PROCEED, NULL);
1709 break;
1710
1711 case (ISDN_CMD_ALERT):
1712 chanp = csta->channel + ic->arg;
1713 if (chanp->debug & 1)
1714 link_debug(chanp, 1, "ALERT");
1715 FsmEvent(&chanp->fi, EV_ALERT, NULL);
1716 break;
1717
1718 case (ISDN_CMD_REDIR):
1719 chanp = csta->channel + ic->arg;
1720 if (chanp->debug & 1)
1721 link_debug(chanp, 1, "REDIR");
1722 memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
1723 FsmEvent(&chanp->fi, EV_REDIR, NULL);
1724 break;
1725
1726 /* protocol specific io commands */
1727 case (ISDN_CMD_PROT_IO):
1728 for (st = csta->stlist; st; st = st->next)
1729 if (st->protocol == (ic->arg & 0xFF))
1730 return(st->lli.l4l3_proto(st, ic));
1731 return(-EINVAL);
1732 break;
1733 default:
1734 if (csta->auxcmd)
1735 return(csta->auxcmd(csta, ic));
1736 return(-EINVAL);
1737 }
1738 return (0);
1739 }
1740
1741 int
1742 HiSax_writebuf_skb(int id, int chan, int ack, struct sk_buff *skb)
1743 {
1744 struct IsdnCardState *csta = hisax_findcard(id);
1745 struct Channel *chanp;
1746 struct PStack *st;
1747 int len = skb->len;
1748 struct sk_buff *nskb;
1749
1750 if (!csta) {
1751 printk(KERN_ERR
1752 "HiSax: if_sendbuf called with invalid driverId!\n");
1753 return -ENODEV;
1754 }
1755 chanp = csta->channel + chan;
1756 st = chanp->b_st;
1757 if (!chanp->data_open) {
1758 link_debug(chanp, 1, "writebuf: channel not open");
1759 return -EIO;
1760 }
1761 if (len > MAX_DATA_SIZE) {
1762 link_debug(chanp, 1, "writebuf: packet too large (%d bytes)", len);
1763 printk(KERN_WARNING "HiSax_writebuf: packet too large (%d bytes) !\n",
1764 len);
1765 return -EINVAL;
1766 }
1767 if (len) {
1768 if ((len + chanp->bcs->tx_cnt) > MAX_DATA_MEM) {
1769 /* Must return 0 here, since this is not an error
1770 * but a temporary lack of resources.
1771 */
1772 if (chanp->debug & 0x800)
1773 link_debug(chanp, 1, "writebuf: no buffers for %d bytes", len);
1774 return 0;
1775 } else if (chanp->debug & 0x800)
1776 link_debug(chanp, 1, "writebuf %d/%d/%d", len, chanp->bcs->tx_cnt,MAX_DATA_MEM);
1777 nskb = skb_clone(skb, GFP_ATOMIC);
1778 if (nskb) {
1779 nskb->truesize = nskb->len;
1780 if (!ack)
1781 nskb->pkt_type = PACKET_NOACK;
1782 if (chanp->l2_active_protocol == ISDN_PROTO_L2_X75I)
1783 st->l3.l3l2(st, DL_DATA | REQUEST, nskb);
1784 else {
1785 chanp->bcs->tx_cnt += len;
1786 st->l2.l2l1(st, PH_DATA | REQUEST, nskb);
1787 }
1788 dev_kfree_skb(skb);
1789 } else
1790 len = 0;
1791 }
1792 return (len);
1793 }
Mirror for ia64_pv_ops.git