drivers/isdn/hisax/callc.c

   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/slab.h>
  21 #include <linux/init.h>
  22 #include "hisax.h"
  23 #include <linux/isdn/capicmd.h>
  24
  25 const char *lli_revision = "$Revision: 2.59.2.4 $";
  26
  27 extern struct IsdnCard cards[];
  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 __printf(3, 4) void
  69 link_debug(struct Channel *chanp, int direction, char *fmt, ...)
  70 {
  71         va_list args;
  72         char tmp[16];
  73
  74         va_start(args, fmt);
  75         sprintf(tmp, "Ch%d %s ", chanp->chan,
  76                 direction ? "LL->HL" : "HL->LL");
  77         VHiSax_putstatus(chanp->cs, tmp, fmt, args);
  78         va_end(args);
  79 }
  80
  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 int __init
 838 CallcNew(void)
 839 {
 840         callcfsm.state_count = STATE_COUNT;
 841         callcfsm.event_count = EVENT_COUNT;
 842         callcfsm.strEvent = strEvent;
 843         callcfsm.strState = strState;
 844         return FsmNew(&callcfsm, fnlist, ARRAY_SIZE(fnlist));
 845 }
 846
 847 void
 848 CallcFree(void)
 849 {
 850         FsmFree(&callcfsm);
 851 }
 852
 853 static void
 854 release_b_st(struct Channel *chanp)
 855 {
 856         struct PStack *st = chanp->b_st;
 857
 858         if(test_and_clear_bit(FLG_START_B, &chanp->Flags)) {
 859                 chanp->bcs->BC_Close(chanp->bcs);
 860                 switch (chanp->l2_active_protocol) {
 861                         case (ISDN_PROTO_L2_X75I):
 862                                 releasestack_isdnl2(st);
 863                                 break;
 864                         case (ISDN_PROTO_L2_HDLC):
 865                         case (ISDN_PROTO_L2_HDLC_56K):
 866                         case (ISDN_PROTO_L2_TRANS):
 867                         case (ISDN_PROTO_L2_MODEM):
 868                         case (ISDN_PROTO_L2_FAX):
 869                                 releasestack_transl2(st);
 870                                 break;
 871                 }
 872         }
 873 }
 874
 875 static struct Channel
 876 *selectfreechannel(struct PStack *st, int bch)
 877 {
 878         struct IsdnCardState *cs = st->l1.hardware;
 879         struct Channel *chanp = st->lli.userdata;
 880         int i;
 881
 882         if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
 883                 i=1;
 884         else
 885                 i=0;
 886
 887         if (!bch) {
 888                 i = 2; /* virtual channel */
 889                 chanp += 2;
 890         }
 891
 892         while (i < ((bch) ? cs->chanlimit : (2 + MAX_WAITING_CALLS))) {
 893                 if (chanp->fi.state == ST_NULL)
 894                         return (chanp);
 895                 chanp++;
 896                 i++;
 897         }
 898
 899         if (bch) /* number of channels is limited */ {
 900                 i = 2; /* virtual channel */
 901                 chanp = st->lli.userdata;
 902                 chanp += i;
 903                 while (i < (2 + MAX_WAITING_CALLS)) {
 904                         if (chanp->fi.state == ST_NULL)
 905                                 return (chanp);
 906                         chanp++;
 907                         i++;
 908                 }
 909         }
 910         return (NULL);
 911 }
 912
 913 static void stat_redir_result(struct IsdnCardState *cs, int chan, ulong result)
 914 {       isdn_ctrl ic;
 915
 916         ic.driver = cs->myid;
 917         ic.command = ISDN_STAT_REDIR;
 918         ic.arg = chan;
 919         ic.parm.num[0] = result;
 920         cs->iif.statcallb(&ic);
 921 } /* stat_redir_result */
 922
 923 static void
 924 dchan_l3l4(struct PStack *st, int pr, void *arg)
 925 {
 926         struct l3_process *pc = arg;
 927         struct IsdnCardState *cs = st->l1.hardware;
 928         struct Channel *chanp;
 929
 930         if(!pc)
 931                 return;
 932
 933         if (pr == (CC_SETUP | INDICATION)) {
 934                 if (!(chanp = selectfreechannel(pc->st, pc->para.bchannel))) {
 935                         pc->para.cause = 0x11;  /* User busy */
 936                         pc->st->lli.l4l3(pc->st, CC_REJECT | REQUEST, pc);
 937                 } else {
 938                         chanp->proc = pc;
 939                         pc->chan = chanp;
 940                         FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
 941                 }
 942                 return;
 943         }
 944         if (!(chanp = pc->chan))
 945                 return;
 946
 947         switch (pr) {
 948                 case (CC_MORE_INFO | INDICATION):
 949                         FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
 950                         break;
 951                 case (CC_DISCONNECT | INDICATION):
 952                         FsmEvent(&chanp->fi, EV_DISCONNECT_IND, NULL);
 953                         break;
 954                 case (CC_RELEASE | CONFIRM):
 955                         FsmEvent(&chanp->fi, EV_RELEASE, NULL);
 956                         break;
 957                 case (CC_SUSPEND | CONFIRM):
 958                         FsmEvent(&chanp->fi, EV_RELEASE, NULL);
 959                         break;
 960                 case (CC_RESUME | CONFIRM):
 961                         FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
 962                         break;
 963                 case (CC_RESUME_ERR):
 964                         FsmEvent(&chanp->fi, EV_RELEASE, NULL);
 965                         break;
 966                 case (CC_RELEASE | INDICATION):
 967                         FsmEvent(&chanp->fi, EV_RELEASE, NULL);
 968                         break;
 969                 case (CC_SETUP_COMPL | INDICATION):
 970                         FsmEvent(&chanp->fi, EV_SETUP_CMPL_IND, NULL);
 971                         break;
 972                 case (CC_SETUP | CONFIRM):
 973                         FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
 974                         break;
 975                 case (CC_CHARGE | INDICATION):
 976                         FsmEvent(&chanp->fi, EV_CINF, NULL);
 977                         break;
 978                 case (CC_NOSETUP_RSP):
 979                         FsmEvent(&chanp->fi, EV_NOSETUP_RSP, NULL);
 980                         break;
 981                 case (CC_SETUP_ERR):
 982                         FsmEvent(&chanp->fi, EV_SETUP_ERR, NULL);
 983                         break;
 984                 case (CC_CONNECT_ERR):
 985                         FsmEvent(&chanp->fi, EV_CONNECT_ERR, NULL);
 986                         break;
 987                 case (CC_RELEASE_ERR):
 988                         FsmEvent(&chanp->fi, EV_RELEASE, NULL);
 989                         break;
 990                 case (CC_PROCEED_SEND | INDICATION):
 991                 case (CC_PROCEEDING | INDICATION):
 992                 case (CC_ALERTING | INDICATION):
 993                 case (CC_PROGRESS | INDICATION):
 994                 case (CC_NOTIFY | INDICATION):
 995                         break;
 996                 case (CC_REDIR | INDICATION):
 997                         stat_redir_result(cs, chanp->chan, pc->redir_result);
 998                         break;
 999                         default:
1000                         if (chanp->debug & 0x800) {
1001                                 HiSax_putstatus(chanp->cs, "Ch",
1002                                         "%d L3->L4 unknown primitiv %#x",
1003                                         chanp->chan, pr);
1004                         }
1005         }
1006 }
1007
1008 static void
1009 dummy_pstack(struct PStack *st, int pr, void *arg) {
1010         printk(KERN_WARNING"call to dummy_pstack pr=%04x arg %lx\n", pr, (long)arg);
1011 }
1012
1013 static int
1014 init_PStack(struct PStack **stp) {
1015         *stp = kmalloc(sizeof(struct PStack), GFP_ATOMIC);
1016         if (!*stp)
1017                 return -ENOMEM;
1018         (*stp)->next = NULL;
1019         (*stp)->l1.l1l2 = dummy_pstack;
1020         (*stp)->l1.l1hw = dummy_pstack;
1021         (*stp)->l1.l1tei = dummy_pstack;
1022         (*stp)->l2.l2tei = dummy_pstack;
1023         (*stp)->l2.l2l1 = dummy_pstack;
1024         (*stp)->l2.l2l3 = dummy_pstack;
1025         (*stp)->l3.l3l2 = dummy_pstack;
1026         (*stp)->l3.l3ml3 = dummy_pstack;
1027         (*stp)->l3.l3l4 = dummy_pstack;
1028         (*stp)->lli.l4l3 = dummy_pstack;
1029         (*stp)->ma.layer = dummy_pstack;
1030         return 0;
1031 }
1032
1033 static int
1034 init_d_st(struct Channel *chanp)
1035 {
1036         struct PStack *st;
1037         struct IsdnCardState *cs = chanp->cs;
1038         char tmp[16];
1039         int err;
1040
1041         err = init_PStack(&chanp->d_st);
1042         if (err)
1043                 return err;
1044         st = chanp->d_st;
1045         st->next = NULL;
1046         HiSax_addlist(cs, st);
1047         setstack_HiSax(st, cs);
1048         st->l2.sap = 0;
1049         st->l2.tei = -1;
1050         st->l2.flag = 0;
1051         test_and_set_bit(FLG_MOD128, &st->l2.flag);
1052         test_and_set_bit(FLG_LAPD, &st->l2.flag);
1053         test_and_set_bit(FLG_ORIG, &st->l2.flag);
1054         st->l2.maxlen = MAX_DFRAME_LEN;
1055         st->l2.window = 1;
1056         st->l2.T200 = 1000;     /* 1000 milliseconds  */
1057         st->l2.N200 = 3;        /* try 3 times        */
1058         st->l2.T203 = 10000;    /* 10000 milliseconds */
1059         if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
1060                 sprintf(tmp, "DCh%d Q.921 ", chanp->chan);
1061         else
1062                 sprintf(tmp, "DCh Q.921 ");
1063         setstack_isdnl2(st, tmp);
1064         setstack_l3dc(st, chanp);
1065         st->lli.userdata = chanp;
1066         st->l3.l3l4 = dchan_l3l4;
1067
1068         return 0;
1069 }
1070
1071 static __printf(2, 3) void
1072 callc_debug(struct FsmInst *fi, char *fmt, ...)
1073 {
1074         va_list args;
1075         struct Channel *chanp = fi->userdata;
1076         char tmp[16];
1077
1078         va_start(args, fmt);
1079         sprintf(tmp, "Ch%d callc ", chanp->chan);
1080         VHiSax_putstatus(chanp->cs, tmp, fmt, args);
1081         va_end(args);
1082 }
1083
1084 static int
1085 init_chan(int chan, struct IsdnCardState *csta)
1086 {
1087         struct Channel *chanp = csta->channel + chan;
1088         int err;
1089
1090         chanp->cs = csta;
1091         chanp->bcs = csta->bcs + chan;
1092         chanp->chan = chan;
1093         chanp->incoming = 0;
1094         chanp->debug = 0;
1095         chanp->Flags = 0;
1096         chanp->leased = 0;
1097         err = init_PStack(&chanp->b_st);
1098         if (err)
1099                 return err;
1100         chanp->b_st->l1.delay = DEFAULT_B_DELAY;
1101         chanp->fi.fsm = &callcfsm;
1102         chanp->fi.state = ST_NULL;
1103         chanp->fi.debug = 0;
1104         chanp->fi.userdata = chanp;
1105         chanp->fi.printdebug = callc_debug;
1106         FsmInitTimer(&chanp->fi, &chanp->dial_timer);
1107         FsmInitTimer(&chanp->fi, &chanp->drel_timer);
1108         if (!chan || (test_bit(FLG_TWO_DCHAN, &csta->HW_Flags) && chan < 2)) {
1109                 err = init_d_st(chanp);
1110                 if (err)
1111                         return err;
1112         } else {
1113                 chanp->d_st = csta->channel->d_st;
1114         }
1115         chanp->data_open = 0;
1116         return 0;
1117 }
1118
1119 int
1120 CallcNewChan(struct IsdnCardState *csta) {
1121         int i, err;
1122
1123         chancount += 2;
1124         err = init_chan(0, csta);
1125         if (err)
1126                 return err;
1127         err = init_chan(1, csta);
1128         if (err)
1129                 return err;
1130         printk(KERN_INFO "HiSax: 2 channels added\n");
1131
1132         for (i = 0; i < MAX_WAITING_CALLS; i++) {
1133                 err = init_chan(i+2,csta);
1134                 if (err)
1135                         return err;
1136         }
1137         printk(KERN_INFO "HiSax: MAX_WAITING_CALLS added\n");
1138         if (test_bit(FLG_PTP, &csta->channel->d_st->l2.flag)) {
1139                 printk(KERN_INFO "LAYER2 WATCHING ESTABLISH\n");
1140                 csta->channel->d_st->lli.l4l3(csta->channel->d_st,
1141                         DL_ESTABLISH | REQUEST, NULL);
1142         }
1143         return (0);
1144 }
1145
1146 static void
1147 release_d_st(struct Channel *chanp)
1148 {
1149         struct PStack *st = chanp->d_st;
1150
1151         if (!st)
1152                 return;
1153         releasestack_isdnl2(st);
1154         releasestack_isdnl3(st);
1155         HiSax_rmlist(st->l1.hardware, st);
1156         kfree(st);
1157         chanp->d_st = NULL;
1158 }
1159
1160 void
1161 CallcFreeChan(struct IsdnCardState *csta)
1162 {
1163         int i;
1164
1165         for (i = 0; i < 2; i++) {
1166                 FsmDelTimer(&csta->channel[i].drel_timer, 74);
1167                 FsmDelTimer(&csta->channel[i].dial_timer, 75);
1168                 if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags))
1169                         release_d_st(csta->channel + i);
1170                 if (csta->channel[i].b_st) {
1171                         release_b_st(csta->channel + i);
1172                         kfree(csta->channel[i].b_st);
1173                         csta->channel[i].b_st = NULL;
1174                 } else
1175                         printk(KERN_WARNING "CallcFreeChan b_st ch%d already freed\n", i);
1176                 if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
1177                         release_d_st(csta->channel + i);
1178                 } else
1179                         csta->channel[i].d_st = NULL;
1180         }
1181 }
1182
1183 static void
1184 lldata_handler(struct PStack *st, int pr, void *arg)
1185 {
1186         struct Channel *chanp = (struct Channel *) st->lli.userdata;
1187         struct sk_buff *skb = arg;
1188
1189         switch (pr) {
1190                 case (DL_DATA  | INDICATION):
1191                         if (chanp->data_open) {
1192                                 if (chanp->debug & 0x800)
1193                                         link_debug(chanp, 0, "lldata: %d", skb->len);
1194                                 chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
1195                         } else {
1196                                 link_debug(chanp, 0, "lldata: channel not open");
1197                                 dev_kfree_skb(skb);
1198                         }
1199                         break;
1200                 case (DL_ESTABLISH | INDICATION):
1201                 case (DL_ESTABLISH | CONFIRM):
1202                         FsmEvent(&chanp->fi, EV_BC_EST, NULL);
1203                         break;
1204                 case (DL_RELEASE | INDICATION):
1205                 case (DL_RELEASE | CONFIRM):
1206                         FsmEvent(&chanp->fi, EV_BC_REL, NULL);
1207                         break;
1208                 default:
1209                         printk(KERN_WARNING "lldata_handler unknown primitive %#x\n",
1210                                 pr);
1211                         break;
1212         }
1213 }
1214
1215 static void
1216 lltrans_handler(struct PStack *st, int pr, void *arg)
1217 {
1218         struct Channel *chanp = (struct Channel *) st->lli.userdata;
1219         struct sk_buff *skb = arg;
1220
1221         switch (pr) {
1222                 case (PH_DATA | INDICATION):
1223                         if (chanp->data_open) {
1224                                 if (chanp->debug & 0x800)
1225                                         link_debug(chanp, 0, "lltrans: %d", skb->len);
1226                                 chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
1227                         } else {
1228                                 link_debug(chanp, 0, "lltrans: channel not open");
1229                                 dev_kfree_skb(skb);
1230                         }
1231                         break;
1232                 case (PH_ACTIVATE | INDICATION):
1233                 case (PH_ACTIVATE | CONFIRM):
1234                         FsmEvent(&chanp->fi, EV_BC_EST, NULL);
1235                         break;
1236                 case (PH_DEACTIVATE | INDICATION):
1237                 case (PH_DEACTIVATE | CONFIRM):
1238                         FsmEvent(&chanp->fi, EV_BC_REL, NULL);
1239                         break;
1240                 default:
1241                         printk(KERN_WARNING "lltrans_handler unknown primitive %#x\n",
1242                                 pr);
1243                         break;
1244         }
1245 }
1246
1247 void
1248 lli_writewakeup(struct PStack *st, int len)
1249 {
1250         struct Channel *chanp = st->lli.userdata;
1251         isdn_ctrl ic;
1252
1253         if (chanp->debug & 0x800)
1254                 link_debug(chanp, 0, "llwakeup: %d", len);
1255         ic.driver = chanp->cs->myid;
1256         ic.command = ISDN_STAT_BSENT;
1257         ic.arg = chanp->chan;
1258         ic.parm.length = len;
1259         chanp->cs->iif.statcallb(&ic);
1260 }
1261
1262 static int
1263 init_b_st(struct Channel *chanp, int incoming)
1264 {
1265         struct PStack *st = chanp->b_st;
1266         struct IsdnCardState *cs = chanp->cs;
1267         char tmp[16];
1268
1269         st->l1.hardware = cs;
1270         if (chanp->leased)
1271                 st->l1.bc = chanp->chan & 1;
1272         else
1273                 st->l1.bc = chanp->proc->para.bchannel - 1;
1274         switch (chanp->l2_active_protocol) {
1275                 case (ISDN_PROTO_L2_X75I):
1276                 case (ISDN_PROTO_L2_HDLC):
1277                         st->l1.mode = L1_MODE_HDLC;
1278                         break;
1279                 case (ISDN_PROTO_L2_HDLC_56K):
1280                         st->l1.mode = L1_MODE_HDLC_56K;
1281                         break;
1282                 case (ISDN_PROTO_L2_TRANS):
1283                         st->l1.mode = L1_MODE_TRANS;
1284                         break;
1285                 case (ISDN_PROTO_L2_MODEM):
1286                         st->l1.mode = L1_MODE_V32;
1287                         break;
1288                 case (ISDN_PROTO_L2_FAX):
1289                         st->l1.mode = L1_MODE_FAX;
1290                         break;
1291         }
1292         chanp->bcs->conmsg = NULL;
1293         if (chanp->bcs->BC_SetStack(st, chanp->bcs))
1294                 return (-1);
1295         st->l2.flag = 0;
1296         test_and_set_bit(FLG_LAPB, &st->l2.flag);
1297         st->l2.maxlen = MAX_DATA_SIZE;
1298         if (!incoming)
1299                 test_and_set_bit(FLG_ORIG, &st->l2.flag);
1300         st->l2.T200 = 1000;     /* 1000 milliseconds */
1301         st->l2.window = 7;
1302         st->l2.N200 = 4;        /* try 4 times       */
1303         st->l2.T203 = 5000;     /* 5000 milliseconds */
1304         st->l3.debug = 0;
1305         switch (chanp->l2_active_protocol) {
1306                 case (ISDN_PROTO_L2_X75I):
1307                         sprintf(tmp, "Ch%d X.75", chanp->chan);
1308                         setstack_isdnl2(st, tmp);
1309                         setstack_l3bc(st, chanp);
1310                         st->l2.l2l3 = lldata_handler;
1311                         st->lli.userdata = chanp;
1312                         test_and_clear_bit(FLG_LLI_L1WAKEUP, &st->lli.flag);
1313                         test_and_set_bit(FLG_LLI_L2WAKEUP, &st->lli.flag);
1314                         st->l2.l2m.debug = chanp->debug & 16;
1315                         st->l2.debug = chanp->debug & 64;
1316                         break;
1317                 case (ISDN_PROTO_L2_HDLC):
1318                 case (ISDN_PROTO_L2_HDLC_56K):
1319                 case (ISDN_PROTO_L2_TRANS):
1320                 case (ISDN_PROTO_L2_MODEM):
1321                 case (ISDN_PROTO_L2_FAX):
1322                         st->l1.l1l2 = lltrans_handler;
1323                         st->lli.userdata = chanp;
1324                         test_and_set_bit(FLG_LLI_L1WAKEUP, &st->lli.flag);
1325                         test_and_clear_bit(FLG_LLI_L2WAKEUP, &st->lli.flag);
1326                         setstack_transl2(st);
1327                         setstack_l3bc(st, chanp);
1328                         break;
1329         }
1330         test_and_set_bit(FLG_START_B, &chanp->Flags);
1331         return (0);
1332 }
1333
1334 static void
1335 leased_l4l3(struct PStack *st, int pr, void *arg)
1336 {
1337         struct Channel *chanp = (struct Channel *) st->lli.userdata;
1338         struct sk_buff *skb = arg;
1339
1340         switch (pr) {
1341                 case (DL_DATA | REQUEST):
1342                         link_debug(chanp, 0, "leased line d-channel DATA");
1343                         dev_kfree_skb(skb);
1344                         break;
1345                 case (DL_ESTABLISH | REQUEST):
1346                         st->l2.l2l1(st, PH_ACTIVATE | REQUEST, NULL);
1347                         break;
1348                 case (DL_RELEASE | REQUEST):
1349                         break;
1350                 default:
1351                         printk(KERN_WARNING "transd_l4l3 unknown primitive %#x\n",
1352                                 pr);
1353                         break;
1354         }
1355 }
1356
1357 static void
1358 leased_l1l2(struct PStack *st, int pr, void *arg)
1359 {
1360         struct Channel *chanp = (struct Channel *) st->lli.userdata;
1361         struct sk_buff *skb = arg;
1362         int i,event = EV_LEASED_REL;
1363
1364         switch (pr) {
1365                 case (PH_DATA | INDICATION):
1366                         link_debug(chanp, 0, "leased line d-channel DATA");
1367                         dev_kfree_skb(skb);
1368                         break;
1369                 case (PH_ACTIVATE | INDICATION):
1370                 case (PH_ACTIVATE | CONFIRM):
1371                         event = EV_LEASED;
1372                 case (PH_DEACTIVATE | INDICATION):
1373                 case (PH_DEACTIVATE | CONFIRM):
1374                         if (test_bit(FLG_TWO_DCHAN, &chanp->cs->HW_Flags))
1375                                 i = 1;
1376                         else
1377                                 i = 0;
1378                         while (i < 2) {
1379                                 FsmEvent(&chanp->fi, event, NULL);
1380                                 chanp++;
1381                                 i++;
1382                         }
1383                         break;
1384                 default:
1385                         printk(KERN_WARNING
1386                                 "transd_l1l2 unknown primitive %#x\n", pr);
1387                         break;
1388         }
1389 }
1390
1391 static void
1392 distr_debug(struct IsdnCardState *csta, int debugflags)
1393 {
1394         int i;
1395         struct Channel *chanp = csta->channel;
1396
1397         for (i = 0; i < (2 + MAX_WAITING_CALLS) ; i++) {
1398                 chanp[i].debug = debugflags;
1399                 chanp[i].fi.debug = debugflags & 2;
1400                 chanp[i].d_st->l2.l2m.debug = debugflags & 8;
1401                 chanp[i].b_st->l2.l2m.debug = debugflags & 0x10;
1402                 chanp[i].d_st->l2.debug = debugflags & 0x20;
1403                 chanp[i].b_st->l2.debug = debugflags & 0x40;
1404                 chanp[i].d_st->l3.l3m.debug = debugflags & 0x80;
1405                 chanp[i].b_st->l3.l3m.debug = debugflags & 0x100;
1406                 chanp[i].b_st->ma.tei_m.debug = debugflags & 0x200;
1407                 chanp[i].b_st->ma.debug = debugflags & 0x200;
1408                 chanp[i].d_st->l1.l1m.debug = debugflags & 0x1000;
1409                 chanp[i].b_st->l1.l1m.debug = debugflags & 0x2000;
1410         }
1411         if (debugflags & 4)
1412                 csta->debug |= DEB_DLOG_HEX;
1413         else
1414                 csta->debug &= ~DEB_DLOG_HEX;
1415 }
1416
1417 static char tmpbuf[256];
1418
1419 static void
1420 capi_debug(struct Channel *chanp, capi_msg *cm)
1421 {
1422         char *t = tmpbuf;
1423
1424         t += QuickHex(t, (u_char *)cm, (cm->Length>50)? 50: cm->Length);
1425         t--;
1426         *t= 0;
1427         HiSax_putstatus(chanp->cs, "Ch", "%d CAPIMSG %s", chanp->chan, tmpbuf);
1428 }
1429
1430 static void
1431 lli_got_fac_req(struct Channel *chanp, capi_msg *cm) {
1432         if ((cm->para[0] != 3) || (cm->para[1] != 0))
1433                 return;
1434         if (cm->para[2]<3)
1435                 return;
1436         if (cm->para[4] != 0)
1437                 return;
1438         switch(cm->para[3]) {
1439                 case 4: /* Suspend */
1440                         strncpy(chanp->setup.phone, &cm->para[5], cm->para[5] +1);
1441                         FsmEvent(&chanp->fi, EV_SUSPEND, cm);
1442                         break;
1443                 case 5: /* Resume */
1444                         strncpy(chanp->setup.phone, &cm->para[5], cm->para[5] +1);
1445                         if (chanp->fi.state == ST_NULL) {
1446                                 FsmEvent(&chanp->fi, EV_RESUME, cm);
1447                         } else {
1448                                 FsmDelTimer(&chanp->dial_timer, 72);
1449                                 FsmAddTimer(&chanp->dial_timer, 80, EV_RESUME, cm, 73);
1450                         }
1451                         break;
1452         }
1453 }
1454
1455 static void
1456 lli_got_manufacturer(struct Channel *chanp, struct IsdnCardState *cs, capi_msg *cm) {
1457         if ((cs->typ == ISDN_CTYPE_ELSA) || (cs->typ == ISDN_CTYPE_ELSA_PNP) ||
1458                 (cs->typ == ISDN_CTYPE_ELSA_PCI)) {
1459                 if (cs->hw.elsa.MFlag) {
1460                         cs->cardmsg(cs, CARD_AUX_IND, cm->para);
1461                 }
1462         }
1463 }
1464
1465
1466 /***************************************************************/
1467 /* Limit the available number of channels for the current card */
1468 /***************************************************************/
1469 static int
1470 set_channel_limit(struct IsdnCardState *cs, int chanmax)
1471 {
1472         isdn_ctrl ic;
1473         int i, ii;
1474
1475         if ((chanmax < 0) || (chanmax > 2))
1476                 return(-EINVAL);
1477         cs->chanlimit = 0;
1478         for (ii = 0; ii < 2; ii++) {
1479                 ic.driver = cs->myid;
1480                 ic.command = ISDN_STAT_DISCH;
1481                 ic.arg = ii;
1482                 if (ii >= chanmax)
1483                         ic.parm.num[0] = 0; /* disabled */
1484                 else
1485                         ic.parm.num[0] = 1; /* enabled */
1486                 i = cs->iif.statcallb(&ic);
1487                 if (i) return(-EINVAL);
1488                 if (ii < chanmax)
1489                         cs->chanlimit++;
1490         }
1491         return(0);
1492 } /* set_channel_limit */
1493
1494 int
1495 HiSax_command(isdn_ctrl * ic)
1496 {
1497         struct IsdnCardState *csta = hisax_findcard(ic->driver);
1498         struct PStack *st;
1499         struct Channel *chanp;
1500         int i;
1501         u_int num;
1502
1503         if (!csta) {
1504                 printk(KERN_ERR
1505                 "HiSax: if_command %d called with invalid driverId %d!\n",
1506                         ic->command, ic->driver);
1507                 return -ENODEV;
1508         }
1509         switch (ic->command) {
1510                 case (ISDN_CMD_SETEAZ):
1511                         chanp = csta->channel + ic->arg;
1512                         break;
1513                 case (ISDN_CMD_SETL2):
1514                         chanp = csta->channel + (ic->arg & 0xff);
1515                         if (chanp->debug & 1)
1516                                 link_debug(chanp, 1, "SETL2 card %d %ld",
1517                                         csta->cardnr + 1, ic->arg >> 8);
1518                         chanp->l2_protocol = ic->arg >> 8;
1519                         break;
1520                 case (ISDN_CMD_SETL3):
1521                         chanp = csta->channel + (ic->arg & 0xff);
1522                         if (chanp->debug & 1)
1523                                 link_debug(chanp, 1, "SETL3 card %d %ld",
1524                                         csta->cardnr + 1, ic->arg >> 8);
1525                         chanp->l3_protocol = ic->arg >> 8;
1526                         break;
1527                 case (ISDN_CMD_DIAL):
1528                         chanp = csta->channel + (ic->arg & 0xff);
1529                         if (chanp->debug & 1)
1530                                 link_debug(chanp, 1, "DIAL %s -> %s (%d,%d)",
1531                                         ic->parm.setup.eazmsn, ic->parm.setup.phone,
1532                                         ic->parm.setup.si1, ic->parm.setup.si2);
1533                         memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
1534                         if (!strcmp(chanp->setup.eazmsn, "0"))
1535                                 chanp->setup.eazmsn[0] = '\0';
1536                         /* this solution is dirty and may be change, if
1537                          * we make a callreference based callmanager */
1538                         if (chanp->fi.state == ST_NULL) {
1539                                 FsmEvent(&chanp->fi, EV_DIAL, NULL);
1540                         } else {
1541                                 FsmDelTimer(&chanp->dial_timer, 70);
1542                                 FsmAddTimer(&chanp->dial_timer, 50, EV_DIAL, NULL, 71);
1543                         }
1544                         break;
1545                 case (ISDN_CMD_ACCEPTB):
1546                         chanp = csta->channel + ic->arg;
1547                         if (chanp->debug & 1)
1548                                 link_debug(chanp, 1, "ACCEPTB");
1549                         FsmEvent(&chanp->fi, EV_ACCEPTB, NULL);
1550                         break;
1551                 case (ISDN_CMD_ACCEPTD):
1552                         chanp = csta->channel + ic->arg;
1553                         memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
1554                         if (chanp->debug & 1)
1555                                 link_debug(chanp, 1, "ACCEPTD");
1556                         FsmEvent(&chanp->fi, EV_ACCEPTD, NULL);
1557                         break;
1558                 case (ISDN_CMD_HANGUP):
1559                         chanp = csta->channel + ic->arg;
1560                         if (chanp->debug & 1)
1561                                 link_debug(chanp, 1, "HANGUP");
1562                         FsmEvent(&chanp->fi, EV_HANGUP, NULL);
1563                         break;
1564                 case (CAPI_PUT_MESSAGE):
1565                         chanp = csta->channel + ic->arg;
1566                         if (chanp->debug & 1)
1567                                 capi_debug(chanp, &ic->parm.cmsg);
1568                         if (ic->parm.cmsg.Length < 8)
1569                                 break;
1570                         switch(ic->parm.cmsg.Command) {
1571                                 case CAPI_FACILITY:
1572                                         if (ic->parm.cmsg.Subcommand == CAPI_REQ)
1573                                                 lli_got_fac_req(chanp, &ic->parm.cmsg);
1574                                         break;
1575                                 case CAPI_MANUFACTURER:
1576                                         if (ic->parm.cmsg.Subcommand == CAPI_REQ)
1577                                                 lli_got_manufacturer(chanp, csta, &ic->parm.cmsg);
1578                                         break;
1579                                 default:
1580                                         break;
1581                         }
1582                         break;
1583                 case (ISDN_CMD_IOCTL):
1584                         switch (ic->arg) {
1585                                 case (0):
1586                                         num = *(unsigned int *) ic->parm.num;
1587                                         HiSax_reportcard(csta->cardnr, num);
1588                                         break;
1589                                 case (1):
1590                                         num = *(unsigned int *) ic->parm.num;
1591                                         distr_debug(csta, num);
1592                                         printk(KERN_DEBUG "HiSax: debugging flags card %d set to %x\n",
1593                                                 csta->cardnr + 1, num);
1594                                         HiSax_putstatus(csta, "debugging flags ",
1595                                                 "card %d set to %x", csta->cardnr + 1, num);
1596                                         break;
1597                                 case (2):
1598                                         num = *(unsigned int *) ic->parm.num;
1599                                         csta->channel[0].b_st->l1.delay = num;
1600                                         csta->channel[1].b_st->l1.delay = num;
1601                                         HiSax_putstatus(csta, "delay ", "card %d set to %d ms",
1602                                                 csta->cardnr + 1, num);
1603                                         printk(KERN_DEBUG "HiSax: delay card %d set to %d ms\n",
1604                                                 csta->cardnr + 1, num);
1605                                         break;
1606                                 case (5):       /* set card in leased mode */
1607                                         num = *(unsigned int *) ic->parm.num;
1608                                         if ((num <1) || (num > 2)) {
1609                                                 HiSax_putstatus(csta, "Set LEASED ",
1610                                                         "wrong channel %d", num);
1611                                                 printk(KERN_WARNING "HiSax: Set LEASED wrong channel %d\n",
1612                                                         num);
1613                                         } else {
1614                                                 num--;
1615                                                 chanp = csta->channel +num;
1616                                                 chanp->leased = 1;
1617                                                 HiSax_putstatus(csta, "Card",
1618                                                         "%d channel %d set leased mode\n",
1619                                                         csta->cardnr + 1, num + 1);
1620                                                 chanp->d_st->l1.l1l2 = leased_l1l2;
1621                                                 chanp->d_st->lli.l4l3 = leased_l4l3;
1622                                                 chanp->d_st->lli.l4l3(chanp->d_st,
1623                                                         DL_ESTABLISH | REQUEST, NULL);
1624                                         }
1625                                         break;
1626                                 case (6):       /* set B-channel test loop */
1627                                         num = *(unsigned int *) ic->parm.num;
1628                                         if (csta->stlist)
1629                                                 csta->stlist->l2.l2l1(csta->stlist,
1630                                                         PH_TESTLOOP | REQUEST, (void *) (long)num);
1631                                         break;
1632                                 case (7):       /* set card in PTP mode */
1633                                         num = *(unsigned int *) ic->parm.num;
1634                                         if (test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
1635                                                 printk(KERN_ERR "HiSax PTP mode only with one TEI possible\n");
1636                                         } else if (num) {
1637                                                 test_and_set_bit(FLG_PTP, &csta->channel[0].d_st->l2.flag);
1638                                                 test_and_set_bit(FLG_FIXED_TEI, &csta->channel[0].d_st->l2.flag);
1639                                                 csta->channel[0].d_st->l2.tei = 0;
1640                                                 HiSax_putstatus(csta, "set card ", "in PTP mode");
1641                                                 printk(KERN_DEBUG "HiSax: set card in PTP mode\n");
1642                                                 printk(KERN_INFO "LAYER2 WATCHING ESTABLISH\n");
1643                                                 csta->channel[0].d_st->lli.l4l3(csta->channel[0].d_st,
1644                                                         DL_ESTABLISH | REQUEST, NULL);
1645                                         } else {
1646                                                 test_and_clear_bit(FLG_PTP, &csta->channel[0].d_st->l2.flag);
1647                                                 test_and_clear_bit(FLG_FIXED_TEI, &csta->channel[0].d_st->l2.flag);
1648                                                 HiSax_putstatus(csta, "set card ", "in PTMP mode");
1649                                                 printk(KERN_DEBUG "HiSax: set card in PTMP mode\n");
1650                                         }
1651                                         break;
1652                                 case (8):       /* set card in FIXED TEI mode */
1653                                         num = *(unsigned int *) ic->parm.num;
1654                                         chanp = csta->channel + (num & 1);
1655                                         num = num >>1;
1656                                         if (num == 127) {
1657                                                 test_and_clear_bit(FLG_FIXED_TEI, &chanp->d_st->l2.flag);
1658                                                 chanp->d_st->l2.tei = -1;
1659                                                 HiSax_putstatus(csta, "set card ", "in VAR TEI mode");
1660                                                 printk(KERN_DEBUG "HiSax: set card in VAR TEI mode\n");
1661                                         } else {
1662                                                 test_and_set_bit(FLG_FIXED_TEI, &chanp->d_st->l2.flag);
1663                                                 chanp->d_st->l2.tei = num;
1664                                                 HiSax_putstatus(csta, "set card ", "in FIXED TEI (%d) mode", num);
1665                                                 printk(KERN_DEBUG "HiSax: set card in FIXED TEI (%d) mode\n",
1666                                                         num);
1667                                         }
1668                                         chanp->d_st->lli.l4l3(chanp->d_st,
1669                                                 DL_ESTABLISH | REQUEST, NULL);
1670                                         break;
1671                                 case (11):
1672                                         num = csta->debug & DEB_DLOG_HEX;
1673                                         csta->debug = *(unsigned int *) ic->parm.num;
1674                                         csta->debug |= num;
1675                                         HiSax_putstatus(cards[0].cs, "l1 debugging ",
1676                                                 "flags card %d set to %x",
1677                                                 csta->cardnr + 1, csta->debug);
1678                                         printk(KERN_DEBUG "HiSax: l1 debugging flags card %d set to %x\n",
1679                                                 csta->cardnr + 1, csta->debug);
1680                                         break;
1681                                 case (13):
1682                                         csta->channel[0].d_st->l3.debug = *(unsigned int *) ic->parm.num;
1683                                         csta->channel[1].d_st->l3.debug = *(unsigned int *) ic->parm.num;
1684                                         HiSax_putstatus(cards[0].cs, "l3 debugging ",
1685                                                 "flags card %d set to %x\n", csta->cardnr + 1,
1686                                                 *(unsigned int *) ic->parm.num);
1687                                         printk(KERN_DEBUG "HiSax: l3 debugging flags card %d set to %x\n",
1688                                                 csta->cardnr + 1, *(unsigned int *) ic->parm.num);
1689                                         break;
1690                                 case (10):
1691                                         i = *(unsigned int *) ic->parm.num;
1692                                         return(set_channel_limit(csta, i));
1693                                 default:
1694                                         if (csta->auxcmd)
1695                                                 return(csta->auxcmd(csta, ic));
1696                                         printk(KERN_DEBUG "HiSax: invalid ioclt %d\n",
1697                                                 (int) ic->arg);
1698                                         return (-EINVAL);
1699                         }
1700                         break;
1701
1702                 case (ISDN_CMD_PROCEED):
1703                         chanp = csta->channel + ic->arg;
1704                         if (chanp->debug & 1)
1705                                 link_debug(chanp, 1, "PROCEED");
1706                         FsmEvent(&chanp->fi, EV_PROCEED, NULL);
1707                         break;
1708
1709                 case (ISDN_CMD_ALERT):
1710                         chanp = csta->channel + ic->arg;
1711                         if (chanp->debug & 1)
1712                                 link_debug(chanp, 1, "ALERT");
1713                         FsmEvent(&chanp->fi, EV_ALERT, NULL);
1714                         break;
1715
1716                 case (ISDN_CMD_REDIR):
1717                         chanp = csta->channel + ic->arg;
1718                         if (chanp->debug & 1)
1719                                 link_debug(chanp, 1, "REDIR");
1720                         memcpy(&chanp->setup, &ic->parm.setup, sizeof(setup_parm));
1721                         FsmEvent(&chanp->fi, EV_REDIR, NULL);
1722                         break;
1723
1724                 /* protocol specific io commands */
1725                 case (ISDN_CMD_PROT_IO):
1726                         for (st = csta->stlist; st; st = st->next)
1727                                 if (st->protocol == (ic->arg & 0xFF))
1728                                         return(st->lli.l4l3_proto(st, ic));
1729                         return(-EINVAL);
1730                         break;
1731                 default:
1732                         if (csta->auxcmd)
1733                                 return(csta->auxcmd(csta, ic));
1734                         return(-EINVAL);
1735         }
1736         return (0);
1737 }
1738
1739 int
1740 HiSax_writebuf_skb(int id, int chan, int ack, struct sk_buff *skb)
1741 {
1742         struct IsdnCardState *csta = hisax_findcard(id);
1743         struct Channel *chanp;
1744         struct PStack *st;
1745         int len = skb->len;
1746         struct sk_buff *nskb;
1747
1748         if (!csta) {
1749                 printk(KERN_ERR
1750                         "HiSax: if_sendbuf called with invalid driverId!\n");
1751                 return -ENODEV;
1752         }
1753         chanp = csta->channel + chan;
1754         st = chanp->b_st;
1755         if (!chanp->data_open) {
1756                 link_debug(chanp, 1, "writebuf: channel not open");
1757                 return -EIO;
1758         }
1759         if (len > MAX_DATA_SIZE) {
1760                 link_debug(chanp, 1, "writebuf: packet too large (%d bytes)", len);
1761                 printk(KERN_WARNING "HiSax_writebuf: packet too large (%d bytes) !\n",
1762                         len);
1763                 return -EINVAL;
1764         }
1765         if (len) {
1766                 if ((len + chanp->bcs->tx_cnt) > MAX_DATA_MEM) {
1767                         /* Must return 0 here, since this is not an error
1768                          * but a temporary lack of resources.
1769                          */
1770                         if (chanp->debug & 0x800)
1771                                 link_debug(chanp, 1, "writebuf: no buffers for %d bytes", len);
1772                         return 0;
1773                 } else if (chanp->debug & 0x800)
1774                         link_debug(chanp, 1, "writebuf %d/%d/%d", len, chanp->bcs->tx_cnt,MAX_DATA_MEM);
1775                 nskb = skb_clone(skb, GFP_ATOMIC);
1776                 if (nskb) {
1777                         nskb->truesize = nskb->len;
1778                         if (!ack)
1779                                 nskb->pkt_type = PACKET_NOACK;
1780                         if (chanp->l2_active_protocol == ISDN_PROTO_L2_X75I)
1781                                 st->l3.l3l2(st, DL_DATA | REQUEST, nskb);
1782                         else {
1783                                 chanp->bcs->tx_cnt += len;
1784                                 st->l2.l2l1(st, PH_DATA | REQUEST, nskb);
1785                         }
1786                         dev_kfree_skb(skb);
1787                 } else
1788                         len = 0;
1789         }
1790         return (len);
1791 }