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