patch-2.0.31 linux/drivers/isdn/hisax/callc.c

Next file: linux/drivers/isdn/hisax/config.c
Previous file: linux/drivers/isdn/hisax/avm_a1.h
Back to the patch index
Back to the overall index

diff -u --recursive --new-file v2.0.30/linux/drivers/isdn/hisax/callc.c linux/drivers/isdn/hisax/callc.c
@@ -0,0 +1,1975 @@
+/* $Id: callc.c,v 1.30 1997/05/29 10:40:43 keil Exp $
+
+ * Author       Karsten Keil (keil@temic-ech.spacenet.de)
+ *              based on the teles driver from Jan den Ouden
+ *
+ * Thanks to    Jan den Ouden
+ *              Fritz Elfert
+ *
+ * $Log: callc.c,v $
+ * Revision 1.30  1997/05/29 10:40:43  keil
+ * chanp->impair was uninitialised
+ *
+ * Revision 1.29  1997/04/23 20:09:49  fritz
+ * Removed tmp, used by removed debugging code.
+ *
+ * Revision 1.28  1997/04/21 13:42:25  keil
+ * Remove unneeded debug
+ *
+ * Revision 1.27  1997/04/16 14:21:01  keil
+ * remove unused variable
+ *
+ * Revision 1.26  1997/04/13 19:55:21  keil
+ * Changes in debugging code
+ *
+ * Revision 1.25  1997/04/06 22:54:08  keil
+ * Using SKB's
+ *
+ * Revision 1.24  1997/03/05 11:28:03  keil
+ * fixed undefined l2tei procedure
+ * a layer1 release delete now the drel timer
+ *
+ * Revision 1.23  1997/03/04 23:07:42  keil
+ * bugfix dial parameter
+ *
+ * Revision 1.22  1997/02/27 13:51:55  keil
+ * Reset B-channel (dlc) statemachine in every release
+ *
+ * Revision 1.21  1997/02/19 09:24:27  keil
+ * Bugfix: Hangup to LL if a ttyI rings
+ *
+ * Revision 1.20  1997/02/17 00:32:47  keil
+ * Bugfix: No Busy reported to LL
+ *
+ * Revision 1.19  1997/02/14 12:23:10  fritz
+ * Added support for new insmod parameter handling.
+ *
+ * Revision 1.18  1997/02/11 01:36:58  keil
+ * Changed setup-interface (incoming and outgoing), cause reporting
+ *
+ * Revision 1.17  1997/02/09 00:23:10  keil
+ * new interface handling, one interface per card
+ * some changes in debug and leased line mode
+ *
+ * Revision 1.16  1997/01/27 23:17:03  keil
+ * delete timers while unloading
+ *
+ * Revision 1.15  1997/01/27 16:00:38  keil
+ * D-channel shutdown delay; improved callback
+ *
+ * Revision 1.14  1997/01/21 22:16:39  keil
+ * new statemachine; leased line support; cleanup for 2.0
+ *
+ * Revision 1.13  1996/12/08 19:51:17  keil
+ * bugfixes from Pekka Sarnila
+ *
+ * Revision 1.12  1996/11/26 20:20:03  keil
+ * fixed warning while compile
+ *
+ * Revision 1.11  1996/11/26 18:43:17  keil
+ * change ioctl 555 --> 55 (555 didn't work)
+ *
+ * Revision 1.10  1996/11/26 18:06:07  keil
+ * fixed missing break statement,ioctl 555 reset modcount
+ *
+ * Revision 1.9  1996/11/18 20:23:19  keil
+ * log writebuf channel not open changed
+ *
+ * Revision 1.8  1996/11/06 17:43:17  keil
+ * more changes for 2.1.X;block fixed ST_PRO_W
+ *
+ * Revision 1.7  1996/11/06 15:13:51  keil
+ * typo 0x64 --->64 in debug code
+ *
+ * Revision 1.6  1996/11/05 19:40:33  keil
+ * X.75 windowsize
+ *
+ * Revision 1.5  1996/10/30 10:11:06  keil
+ * debugging LOCK changed;ST_REL_W EV_HANGUP added
+ *
+ * Revision 1.4  1996/10/27 22:20:16  keil
+ * alerting bugfixes
+ * no static b-channel<->channel mapping
+ *
+ * Revision 1.2  1996/10/16 21:29:45  keil
+ * compile bug as "not module"
+ * Callback with euro
+ *
+ * Revision 1.1  1996/10/13 20:04:50  keil
+ * Initial revision
+ *
+ */
+
+#define __NO_VERSION__
+#include "hisax.h"
+
+#ifdef MODULE
+#if (LINUX_VERSION_CODE < 0x020111)
+extern long mod_use_count_;
+#define MOD_USE_COUNT mod_use_count_
+#else
+#define MOD_USE_COUNT ((&__this_module)->usecount)
+#endif
+#endif				/* MODULE */
+
+const char *l4_revision = "$Revision: 1.30 $";
+
+extern struct IsdnCard cards[];
+extern int nrcards;
+extern void HiSax_mod_dec_use_count(void);
+extern void HiSax_mod_inc_use_count(void);
+
+static int init_ds(struct Channel *chanp, int incoming);
+static void release_ds(struct Channel *chanp);
+
+static struct Fsm callcfsm =
+{NULL, 0, 0};
+static struct Fsm lcfsm =
+{NULL, 0, 0};
+
+static int chancount = 0;
+
+/* Flags for remembering action done in l4 */
+
+#define  FLG_START_D	0x0001
+#define  FLG_ESTAB_D	0x0002
+#define  FLG_CALL_SEND	0x0004
+#define  FLG_CALL_REC   0x0008
+#define  FLG_CALL_ALERT	0x0010
+#define  FLG_START_B	0x0020
+#define  FLG_CONNECT_B	0x0040
+#define  FLG_LL_DCONN	0x0080
+#define  FLG_LL_BCONN	0x0100
+#define  FLG_DISC_SEND	0x0200
+#define  FLG_DISC_REC	0x0400
+#define  FLG_REL_REC	0x0800
+
+#define  SETBIT(flg, item)  flg |= item
+#define  RESBIT(flg, item)  flg &= (~item)
+
+/*
+ * Because of callback it's a good idea to delay the shutdown of the d-channel
+ */
+#define	DREL_TIMER_VALUE 30000
+
+/*
+ * Find card with given driverId
+ */
+static inline struct IsdnCardState
+*
+hisax_findcard(int driverid)
+{
+	int i;
+
+	for (i = 0; i < nrcards; i++)
+		if (cards[i].sp)
+			if (cards[i].sp->myid == driverid)
+				return (cards[i].sp);
+	return (struct IsdnCardState *) 0;
+}
+
+static void
+link_debug(struct Channel *chanp, char *s, int direction)
+{
+	char tmp[100], tm[32];
+
+	jiftime(tm, jiffies);
+	sprintf(tmp, "%s Channel %d %s %s\n", tm, chanp->chan,
+		direction ? "LL->HL" : "HL->LL", s);
+	HiSax_putstatus(chanp->sp, tmp);
+}
+
+
+enum {
+	ST_NULL,		/*  0 inactive */
+	ST_OUT_WAIT_D,		/*  1 outgoing, awaiting d-channel establishment */
+	ST_IN_WAIT_D,		/*  2 incoming, awaiting d-channel establishment */
+	ST_OUT_DIAL,		/*  3 outgoing, SETUP send; awaiting confirm */
+	ST_IN_WAIT_LL,		/*  4 incoming call received; wait for LL confirm */
+	ST_IN_ALERT_SEND,	/*  5 incoming call received; ALERT send */
+	ST_IN_WAIT_CONN_ACK,	/*  6 incoming CONNECT send; awaiting CONN_ACK */
+	ST_WAIT_BCONN,		/*  7 CONNECT/CONN_ACK received, awaiting b-channel prot. estbl. */
+	ST_ACTIVE,		/*  8 active, b channel prot. established */
+	ST_WAIT_BRELEASE,	/*  9 call clear. (initiator), awaiting b channel prot. rel. */
+	ST_WAIT_BREL_DISC,	/* 10 call clear. (receiver), DISCONNECT req. received */
+	ST_WAIT_DCOMMAND,	/* 11 call clear. (receiver), awaiting DCHANNEL message */
+	ST_WAIT_DRELEASE,	/* 12 DISCONNECT sent, awaiting RELEASE */
+	ST_WAIT_D_REL_CNF,	/* 13 RELEASE sent, awaiting RELEASE confirm */
+	ST_WAIT_DSHUTDOWN,	/*  14 awaiting d-channel shutdown */
+};
+
+#define STATE_COUNT (ST_WAIT_DSHUTDOWN +1)
+
+static char *strState[] =
+{
+	"ST_NULL",
+	"ST_OUT_WAIT_D",
+	"ST_IN_WAIT_D",
+	"ST_OUT_DIAL",
+	"ST_IN_WAIT_LL",
+	"ST_IN_ALERT_SEND",
+	"ST_IN_WAIT_CONN_ACK",
+	"ST_WAIT_BCONN",
+	"ST_ACTIVE",
+	"ST_WAIT_BRELEASE",
+	"ST_WAIT_BREL_DISC",
+	"ST_WAIT_DCOMMAND",
+	"ST_WAIT_DRELEASE",
+	"ST_WAIT_D_REL_CNF",
+	"ST_WAIT_DSHUTDOWN",
+};
+
+enum {
+	EV_DIAL,		/*  0 */
+	EV_SETUP_CNF,		/*  1 */
+	EV_ACCEPTB,		/*  2 */
+	EV_DISCONNECT_IND,	/*  3 */
+	EV_RELEASE_CNF,		/*  4 */
+	EV_DLEST,		/*  5 */
+	EV_DLRL,		/*  6 */
+	EV_SETUP_IND,		/*  7 */
+	EV_RELEASE_IND,		/*  8 */
+	EV_ACCEPTD,		/*  9 */
+	EV_SETUP_CMPL_IND,	/* 10 */
+	EV_BC_EST,		/* 11 */
+	EV_WRITEBUF,		/* 12 */
+	EV_DATAIN,		/* 13 */
+	EV_HANGUP,		/* 14 */
+	EV_BC_REL,		/* 15 */
+	EV_CINF,		/* 16 */
+	EV_SUSPEND,		/* 17 */
+	EV_RESUME,		/* 18 */
+	EV_SHUTDOWN_D,		/* 19 */
+	EV_NOSETUP_RSP,		/* 20 */
+	EV_SETUP_ERR,		/* 21 */
+	EV_CONNECT_ERR,		/* 22 */
+	EV_RELEASE_ERR,		/* 23 */
+};
+
+#define EVENT_COUNT (EV_RELEASE_ERR +1)
+
+static char *strEvent[] =
+{
+	"EV_DIAL",
+	"EV_SETUP_CNF",
+	"EV_ACCEPTB",
+	"EV_DISCONNECT_IND",
+	"EV_RELEASE_CNF",
+	"EV_DLEST",
+	"EV_DLRL",
+	"EV_SETUP_IND",
+	"EV_RELEASE_IND",
+	"EV_ACCEPTD",
+	"EV_SETUP_CMPL_IND",
+	"EV_BC_EST",
+	"EV_WRITEBUF",
+	"EV_DATAIN",
+	"EV_HANGUP",
+	"EV_BC_REL",
+	"EV_CINF",
+	"EV_SUSPEND",
+	"EV_RESUME",
+	"EV_SHUTDOWN_D",
+	"EV_NOSETUP_RSP",
+	"EV_SETUP_ERR",
+	"EV_CONNECT_ERR",
+	"EV_RELEASE_ERR",
+};
+
+enum {
+	ST_LC_NULL,
+	ST_LC_ACTIVATE_WAIT,
+	ST_LC_DELAY,
+	ST_LC_ESTABLISH_WAIT,
+	ST_LC_CONNECTED,
+	ST_LC_FLUSH_WAIT,
+	ST_LC_FLUSH_DELAY,
+	ST_LC_RELEASE_WAIT,
+};
+
+#define LC_STATE_COUNT (ST_LC_RELEASE_WAIT+1)
+
+static char *strLcState[] =
+{
+	"ST_LC_NULL",
+	"ST_LC_ACTIVATE_WAIT",
+	"ST_LC_DELAY",
+	"ST_LC_ESTABLISH_WAIT",
+	"ST_LC_CONNECTED",
+	"ST_LC_FLUSH_WAIT",
+	"ST_LC_FLUSH_DELAY",
+	"ST_LC_RELEASE_WAIT",
+};
+
+enum {
+	EV_LC_ESTABLISH,
+	EV_LC_PH_ACTIVATE,
+	EV_LC_PH_DEACTIVATE,
+	EV_LC_DL_ESTABLISH,
+	EV_LC_TIMER,
+	EV_LC_DL_FLUSH,
+	EV_LC_DL_RELEASE,
+	EV_LC_FLUSH,
+	EV_LC_RELEASE,
+};
+
+#define LC_EVENT_COUNT (EV_LC_RELEASE+1)
+
+static char *strLcEvent[] =
+{
+	"EV_LC_ESTABLISH",
+	"EV_LC_PH_ACTIVATE",
+	"EV_LC_PH_DEACTIVATE",
+	"EV_LC_DL_ESTABLISH",
+	"EV_LC_TIMER",
+	"EV_LC_DL_FLUSH",
+	"EV_LC_DL_RELEASE",
+	"EV_LC_FLUSH",
+	"EV_LC_RELEASE",
+};
+
+#define LC_D  0
+#define LC_B  1
+
+static inline void
+l4_deliver_cause(struct Channel *chanp)
+{
+	isdn_ctrl ic;
+
+	if (chanp->para.cause < 0)
+		return;
+	ic.driver = chanp->sp->myid;
+	ic.command = ISDN_STAT_CAUSE;
+	ic.arg = chanp->chan;
+	if (chanp->sp->protocol == ISDN_PTYPE_EURO)
+		sprintf(ic.parm.num, "E%02X%02X", chanp->para.loc & 0x7f,
+			chanp->para.cause & 0x7f);
+	else
+		sprintf(ic.parm.num, "%02X%02X", chanp->para.loc & 0x7f,
+			chanp->para.cause & 0x7f);
+	chanp->sp->iif.statcallb(&ic);
+}
+
+/*
+ * Dial out
+ */
+static void
+l4_prep_dialout(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+
+	FsmChangeState(fi, ST_OUT_WAIT_D);
+	FsmDelTimer(&chanp->drel_timer, 60);
+	FsmDelTimer(&chanp->dial_timer, 73);
+
+	chanp->l2_active_protocol = chanp->l2_protocol;
+	chanp->incoming = 0;
+	chanp->lc_b.l2_start = !0;
+	switch (chanp->l2_active_protocol) {
+		case (ISDN_PROTO_L2_X75I):
+			chanp->lc_b.l2_establish = !0;
+			break;
+		case (ISDN_PROTO_L2_HDLC):
+		case (ISDN_PROTO_L2_TRANS):
+			chanp->lc_b.l2_establish = 0;
+			break;
+		default:
+			printk(KERN_WARNING "l4_prep_dialout unknown protocol\n");
+			break;
+	}
+	if (chanp->Flags & FLG_ESTAB_D) {
+		FsmEvent(fi, EV_DLEST, NULL);
+	} else {
+		chanp->Flags = FLG_START_D;
+		if (chanp->leased) {
+			chanp->lc_d.l2_establish = 0;
+		}
+		FsmEvent(&chanp->lc_d.lcfi, EV_LC_ESTABLISH, NULL);
+	}
+}
+
+static void
+l4_do_dialout(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+
+	FsmChangeState(fi, ST_OUT_DIAL);
+	if (chanp->leased) {
+		chanp->para.bchannel = (chanp->chan & 1) + 1;
+		FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
+	} else {
+		SETBIT(chanp->Flags, FLG_ESTAB_D);
+		chanp->para.callref = chanp->outcallref;
+		chanp->outcallref++;
+		if (chanp->outcallref == 128)
+			chanp->outcallref = 64;
+		chanp->is.l4.l4l3(&chanp->is, CC_SETUP_REQ, NULL);
+		SETBIT(chanp->Flags, FLG_CALL_SEND);
+	}
+}
+
+static void
+l4_init_bchan_out(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	FsmChangeState(fi, ST_WAIT_BCONN);
+	SETBIT(chanp->Flags, FLG_LL_DCONN);
+	if (chanp->debug & 1)
+		link_debug(chanp, "STAT_DCONN", 0);
+	ic.driver = chanp->sp->myid;
+	ic.command = ISDN_STAT_DCONN;
+	ic.arg = chanp->chan;
+	chanp->sp->iif.statcallb(&ic);
+	init_ds(chanp, 0);
+	SETBIT(chanp->Flags, FLG_START_B);
+	FsmEvent(&chanp->lc_b.lcfi, EV_LC_ESTABLISH, NULL);
+}
+
+static void
+l4_go_active(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	FsmChangeState(fi, ST_ACTIVE);
+	chanp->data_open = !0;
+	SETBIT(chanp->Flags, FLG_CONNECT_B);
+	if (chanp->debug & 1)
+		link_debug(chanp, "STAT_BCONN", 0);
+	SETBIT(chanp->Flags, FLG_LL_BCONN);
+	ic.driver = chanp->sp->myid;
+	ic.command = ISDN_STAT_BCONN;
+	ic.arg = chanp->chan;
+	chanp->sp->iif.statcallb(&ic);
+}
+
+/* incomming call */
+
+static void
+l4_start_dchan(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+
+	FsmChangeState(fi, ST_IN_WAIT_D);
+	FsmDelTimer(&chanp->drel_timer, 61);
+	if (chanp->Flags & FLG_ESTAB_D) {
+		FsmEvent(fi, EV_DLEST, NULL);
+	} else {
+		chanp->Flags = FLG_START_D;
+		FsmEvent(&chanp->lc_d.lcfi, EV_LC_ESTABLISH, NULL);
+	}
+}
+
+static void
+l4_deliver_call(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+	int ret;
+	char txt[32];
+
+	/*
+	 * Report incoming calls only once to linklevel, use CallFlags
+	 * which is set to 3 with each broadcast message in isdnl1.c
+	 * and resetted if a interface  answered the STAT_ICALL.
+	 */
+	if ((chanp->sp) && (chanp->sp->CallFlags == 3)) {
+		FsmChangeState(fi, ST_IN_WAIT_LL);
+		SETBIT(chanp->Flags, FLG_ESTAB_D);
+		SETBIT(chanp->Flags, FLG_CALL_REC);
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_ICALL", 0);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_ICALL;
+		ic.arg = chanp->chan;
+		/*
+		 * No need to return "unknown" for calls without OAD,
+		 * cause that's handled in linklevel now (replaced by '0')
+		 */
+		ic.parm.setup = chanp->para.setup;
+		ret = chanp->sp->iif.statcallb(&ic);
+		if (chanp->debug & 1) {
+			sprintf(txt, "statcallb ret=%d", ret);
+			link_debug(chanp, txt, 1);
+		}
+		if (ret)	/* if a interface knows this call, reset the CallFlag
+				   * to avoid a second Call report to the linklevel
+				 */
+			chanp->sp->CallFlags &= ~(chanp->chan + 1);
+		switch (ret) {
+			case 1:	/* OK, anybody likes this call */
+				FsmChangeState(fi, ST_IN_ALERT_SEND);
+				SETBIT(chanp->Flags, FLG_CALL_ALERT);
+				chanp->is.l4.l4l3(&chanp->is, CC_ALERTING_REQ, NULL);
+				break;
+			case 2:	/* Rejecting Call */
+				RESBIT(chanp->Flags, FLG_CALL_REC);
+				break;
+			case 0:	/* OK, nobody likes this call */
+			default:	/* statcallb problems */
+				chanp->is.l4.l4l3(&chanp->is, CC_IGNORE, NULL);
+				FsmChangeState(fi, ST_NULL);
+				chanp->Flags = FLG_ESTAB_D;
+				FsmAddTimer(&chanp->drel_timer, DREL_TIMER_VALUE, EV_SHUTDOWN_D, NULL, 61);
+				break;
+		}
+	} else {
+		chanp->is.l4.l4l3(&chanp->is, CC_IGNORE, NULL);
+		FsmChangeState(fi, ST_NULL);
+		chanp->Flags = FLG_ESTAB_D;
+		FsmAddTimer(&chanp->drel_timer, DREL_TIMER_VALUE, EV_SHUTDOWN_D, NULL, 62);
+	}
+}
+
+static void
+l4_send_dconnect(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+
+	FsmChangeState(fi, ST_IN_WAIT_CONN_ACK);
+	chanp->is.l4.l4l3(&chanp->is, CC_SETUP_RSP, NULL);
+}
+
+static void
+l4_init_bchan_in(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	FsmChangeState(fi, ST_WAIT_BCONN);
+	SETBIT(chanp->Flags, FLG_LL_DCONN);
+	if (chanp->debug & 1)
+		link_debug(chanp, "STAT_DCONN", 0);
+	ic.driver = chanp->sp->myid;
+	ic.command = ISDN_STAT_DCONN;
+	ic.arg = chanp->chan;
+	chanp->sp->iif.statcallb(&ic);
+	chanp->l2_active_protocol = chanp->l2_protocol;
+	chanp->incoming = !0;
+	chanp->lc_b.l2_start = 0;
+	switch (chanp->l2_active_protocol) {
+		case (ISDN_PROTO_L2_X75I):
+			chanp->lc_b.l2_establish = !0;
+			break;
+		case (ISDN_PROTO_L2_HDLC):
+		case (ISDN_PROTO_L2_TRANS):
+			chanp->lc_b.l2_establish = 0;
+			break;
+		default:
+			printk(KERN_WARNING "r9 unknown protocol\n");
+			break;
+	}
+	init_ds(chanp, !0);
+	SETBIT(chanp->Flags, FLG_START_B);
+	FsmEvent(&chanp->lc_b.lcfi, EV_LC_ESTABLISH, NULL);
+}
+
+/* Call clearing */
+
+static void
+l4_reject_call(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+
+	FsmChangeState(fi, ST_WAIT_DRELEASE);
+	chanp->para.cause = 0x15;	/* Call Rejected */
+	chanp->is.l4.l4l3(&chanp->is, CC_REJECT_REQ, NULL);
+	SETBIT(chanp->Flags, FLG_DISC_SEND);
+}
+
+static void
+l4_cancel_call(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	FsmChangeState(fi, ST_WAIT_DRELEASE);
+	if (chanp->Flags & FLG_LL_BCONN) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_BHUP", 0);
+		RESBIT(chanp->Flags, FLG_LL_BCONN);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_BHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+	}
+	if (chanp->Flags & FLG_START_B) {
+		release_ds(chanp);
+		RESBIT(chanp->Flags, FLG_START_B);
+	}
+	chanp->para.cause = 0x10;	/* Normal Call Clearing */
+	chanp->is.l4.l4l3(&chanp->is, CC_DISCONNECT_REQ, NULL);
+	SETBIT(chanp->Flags, FLG_DISC_SEND);
+}
+
+static void
+l4_shutdown_d(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+
+	FsmChangeState(fi, ST_WAIT_DSHUTDOWN);
+	FsmDelTimer(&chanp->drel_timer, 62);
+	RESBIT(chanp->Flags, FLG_ESTAB_D);
+	FsmEvent(&chanp->lc_d.lcfi, EV_LC_RELEASE, NULL);
+}
+
+static void
+l4_timeout_d(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	if (chanp->Flags & FLG_LL_DCONN) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_DHUP", 0);
+		RESBIT(chanp->Flags, FLG_LL_DCONN);
+		l4_deliver_cause(chanp);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_DHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+	}
+	FsmChangeState(fi, ST_NULL);
+	chanp->Flags = FLG_ESTAB_D;
+	FsmAddTimer(&chanp->drel_timer, DREL_TIMER_VALUE, EV_SHUTDOWN_D, NULL, 60);
+}
+
+static void
+l4_go_null(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+
+	FsmChangeState(fi, ST_NULL);
+	chanp->Flags = 0;
+	FsmDelTimer(&chanp->drel_timer, 63);
+}
+
+static void
+l4_disconn_bchan(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+
+	chanp->data_open = 0;
+	FsmChangeState(fi, ST_WAIT_BRELEASE);
+	RESBIT(chanp->Flags, FLG_CONNECT_B);
+	FsmEvent(&chanp->lc_b.lcfi, EV_LC_RELEASE, NULL);
+}
+
+static void
+l4_send_d_disc(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+
+	if (chanp->Flags & (FLG_DISC_REC | FLG_REL_REC))
+		return;
+	FsmChangeState(fi, ST_WAIT_DRELEASE);
+	if (chanp->Flags & FLG_LL_BCONN) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_BHUP", 0);
+		RESBIT(chanp->Flags, FLG_LL_BCONN);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_BHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+	}
+	if (chanp->Flags & FLG_START_B) {
+		release_ds(chanp);
+		RESBIT(chanp->Flags, FLG_START_B);
+	}
+	chanp->para.cause = 0x10;	/* Normal Call Clearing */
+	chanp->is.l4.l4l3(&chanp->is, CC_DISCONNECT_REQ, NULL);
+	SETBIT(chanp->Flags, FLG_DISC_SEND);
+}
+
+static void
+l4_released_bchan(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	FsmChangeState(fi, ST_WAIT_DCOMMAND);
+	chanp->data_open = 0;
+	if (chanp->Flags & FLG_LL_BCONN) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_BHUP", 0);
+		RESBIT(chanp->Flags, FLG_LL_BCONN);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_BHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+	}
+	release_ds(chanp);
+	RESBIT(chanp->Flags, FLG_START_B);
+}
+
+
+static void
+l4_release_bchan(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+
+	chanp->data_open = 0;
+	SETBIT(chanp->Flags, FLG_DISC_REC);
+	FsmChangeState(fi, ST_WAIT_BREL_DISC);
+	RESBIT(chanp->Flags, FLG_CONNECT_B);
+	FsmEvent(&chanp->lc_b.lcfi, EV_LC_RELEASE, NULL);
+}
+
+static void
+l4_received_d_rel(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	chanp->data_open = 0;
+	FsmChangeState(fi, ST_WAIT_DSHUTDOWN);
+	SETBIT(chanp->Flags, FLG_REL_REC);
+	if (chanp->Flags & FLG_CONNECT_B) {
+		chanp->lc_b.l2_establish = 0;	/* direct reset in lc_b.lcfi */
+		FsmEvent(&chanp->lc_b.lcfi, EV_LC_RELEASE, NULL);
+		RESBIT(chanp->Flags, FLG_CONNECT_B);
+	}
+	if (chanp->Flags & FLG_LL_BCONN) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_BHUP", 0);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_BHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+		RESBIT(chanp->Flags, FLG_LL_BCONN);
+	}
+	if (chanp->Flags & FLG_START_B) {
+		release_ds(chanp);
+		RESBIT(chanp->Flags, FLG_START_B);
+	}
+	if (chanp->Flags & (FLG_LL_DCONN | FLG_CALL_SEND | FLG_CALL_ALERT)) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_DHUP", 0);
+		l4_deliver_cause(chanp);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_DHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+	}
+	FsmEvent(&chanp->lc_d.lcfi, EV_LC_FLUSH, NULL);
+	RESBIT(chanp->Flags, FLG_ESTAB_D);
+	RESBIT(chanp->Flags, FLG_DISC_SEND);
+	RESBIT(chanp->Flags, FLG_CALL_REC);
+	RESBIT(chanp->Flags, FLG_CALL_ALERT);
+	RESBIT(chanp->Flags, FLG_LL_DCONN);
+	RESBIT(chanp->Flags, FLG_CALL_SEND);
+}
+
+static void
+l4_received_d_relcnf(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	chanp->data_open = 0;
+	FsmChangeState(fi, ST_WAIT_DSHUTDOWN);
+	if (chanp->Flags & FLG_CONNECT_B) {
+		chanp->lc_b.l2_establish = 0;	/* direct reset in lc_b.lcfi */
+		FsmEvent(&chanp->lc_b.lcfi, EV_LC_RELEASE, NULL);
+		RESBIT(chanp->Flags, FLG_CONNECT_B);
+	}
+	if (chanp->Flags & FLG_LL_BCONN) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_BHUP", 0);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_BHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+		RESBIT(chanp->Flags, FLG_LL_BCONN);
+	}
+	if (chanp->Flags & FLG_START_B) {
+		release_ds(chanp);
+		RESBIT(chanp->Flags, FLG_START_B);
+	}
+	if (chanp->Flags & (FLG_LL_DCONN | FLG_CALL_SEND | FLG_CALL_ALERT)) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_DHUP", 0);
+		l4_deliver_cause(chanp);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_DHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+	}
+	FsmEvent(&chanp->lc_d.lcfi, EV_LC_RELEASE, NULL);
+	RESBIT(chanp->Flags, FLG_ESTAB_D);
+	RESBIT(chanp->Flags, FLG_DISC_SEND);
+	RESBIT(chanp->Flags, FLG_CALL_REC);
+	RESBIT(chanp->Flags, FLG_CALL_ALERT);
+	RESBIT(chanp->Flags, FLG_LL_DCONN);
+	RESBIT(chanp->Flags, FLG_CALL_SEND);
+}
+
+static void
+l4_received_d_disc(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	chanp->data_open = 0;
+	FsmChangeState(fi, ST_WAIT_D_REL_CNF);
+	SETBIT(chanp->Flags, FLG_DISC_REC);
+	if (chanp->Flags & FLG_LL_BCONN) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_BHUP", 0);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_BHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+		RESBIT(chanp->Flags, FLG_LL_BCONN);
+	}
+	if (chanp->Flags & FLG_START_B) {
+		release_ds(chanp);
+		RESBIT(chanp->Flags, FLG_START_B);
+	}
+	if (chanp->Flags & (FLG_LL_DCONN | FLG_CALL_SEND | FLG_CALL_ALERT)) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_DHUP", 0);
+		l4_deliver_cause(chanp);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_DHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+	}
+	RESBIT(chanp->Flags, FLG_LL_DCONN);
+	RESBIT(chanp->Flags, FLG_CALL_SEND);
+	RESBIT(chanp->Flags, FLG_CALL_ALERT);
+	chanp->is.l4.l4l3(&chanp->is, CC_RELEASE_REQ, NULL);
+}
+
+/* processing charge info */
+static void
+l4_charge_info(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	ic.driver = chanp->sp->myid;
+	ic.command = ISDN_STAT_CINF;
+	ic.arg = chanp->chan;
+	sprintf(ic.parm.num, "%d", chanp->para.chargeinfo);
+	chanp->sp->iif.statcallb(&ic);
+}
+
+/* error procedures */
+
+static void
+l4_no_dchan(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	if (chanp->debug & 1)
+		link_debug(chanp, "STAT_NODCH", 0);
+	ic.driver = chanp->sp->myid;
+	ic.command = ISDN_STAT_NODCH;
+	ic.arg = chanp->chan;
+	chanp->sp->iif.statcallb(&ic);
+	chanp->Flags = 0;
+	FsmChangeState(fi, ST_NULL);
+	FsmEvent(&chanp->lc_d.lcfi, EV_LC_RELEASE, NULL);
+}
+
+static void
+l4_no_dchan_ready(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	if (chanp->debug & 1)
+		link_debug(chanp, "STAT_DHUP", 0);
+	ic.driver = chanp->sp->myid;
+	ic.command = ISDN_STAT_DHUP;
+	ic.arg = chanp->chan;
+	chanp->sp->iif.statcallb(&ic);
+}
+
+static void
+l4_no_dchan_in(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+
+	chanp->is.l4.l4l3(&chanp->is, CC_DLRL, NULL);
+	chanp->Flags = 0;
+	FsmChangeState(fi, ST_NULL);
+	FsmEvent(&chanp->lc_d.lcfi, EV_LC_RELEASE, NULL);
+}
+
+static void
+l4_no_setup_rsp(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	chanp->Flags = 0;
+	FsmChangeState(fi, ST_NULL);
+	FsmEvent(&chanp->lc_d.lcfi, EV_LC_RELEASE, NULL);
+	if (chanp->debug & 1)
+		link_debug(chanp, "STAT_DHUP", 0);
+	ic.driver = chanp->sp->myid;
+	ic.command = ISDN_STAT_DHUP;
+	ic.arg = chanp->chan;
+	chanp->sp->iif.statcallb(&ic);
+}
+
+static void
+l4_setup_err(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	FsmChangeState(fi, ST_WAIT_DRELEASE);
+	if (chanp->Flags & FLG_LL_DCONN) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_DHUP", 0);
+		RESBIT(chanp->Flags, FLG_LL_DCONN);
+		l4_deliver_cause(chanp);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_DHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+	}
+	SETBIT(chanp->Flags, FLG_DISC_SEND);	/* DISCONN was sent from L3 */
+}
+
+static void
+l4_connect_err(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	FsmChangeState(fi, ST_WAIT_DRELEASE);
+	if (chanp->Flags & FLG_LL_DCONN) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_DHUP", 0);
+		RESBIT(chanp->Flags, FLG_LL_DCONN);
+		l4_deliver_cause(chanp);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_DHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+	}
+	SETBIT(chanp->Flags, FLG_DISC_SEND);	/* DISCONN was sent from L3 */
+}
+
+static void
+l4_active_dlrl(struct FsmInst *fi, int event, void *arg)
+{
+	struct Channel *chanp = fi->userdata;
+	isdn_ctrl ic;
+
+	chanp->data_open = 0;
+	FsmChangeState(fi, ST_NULL);
+	if (chanp->Flags & FLG_CONNECT_B) {
+		chanp->lc_b.l2_establish = 0;	/* direct reset in lc_b.lcfi */
+		FsmEvent(&chanp->lc_b.lcfi, EV_LC_RELEASE, NULL);
+		RESBIT(chanp->Flags, FLG_CONNECT_B);
+	}
+	if (chanp->Flags & FLG_LL_BCONN) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_BHUP", 0);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_BHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+		RESBIT(chanp->Flags, FLG_LL_BCONN);
+	}
+	if (chanp->Flags & FLG_START_B) {
+		release_ds(chanp);
+		RESBIT(chanp->Flags, FLG_START_B);
+	}
+	if (chanp->Flags & FLG_LL_DCONN) {
+		if (chanp->debug & 1)
+			link_debug(chanp, "STAT_DHUP", 0);
+		RESBIT(chanp->Flags, FLG_LL_DCONN);
+		if (chanp->sp->protocol == ISDN_PTYPE_EURO) {
+			chanp->para.cause = 0x2f;
+			chanp->para.loc = 0;
+		} else {
+			chanp->para.cause = 0x70;
+			chanp->para.loc = 0;
+		}
+		l4_deliver_cause(chanp);
+		ic.driver = chanp->sp->myid;
+		ic.command = ISDN_STAT_DHUP;
+		ic.arg = chanp->chan;
+		chanp->sp->iif.statcallb(&ic);
+	}
+	chanp->Flags = 0;
+	chanp->is.l4.l4l3(&chanp->is, CC_DLRL, NULL);
+	FsmEvent(&chanp->lc_d.lcfi, EV_LC_RELEASE, NULL);
+}
+/* *INDENT-OFF* */
+static struct FsmNode fnlist[] =
+{
+	{ST_NULL,		EV_DIAL,		l4_prep_dialout},
+	{ST_NULL,		EV_SETUP_IND,		l4_start_dchan},
+	{ST_NULL,		EV_SHUTDOWN_D,		l4_shutdown_d},
+	{ST_NULL,		EV_DLRL,		l4_go_null},
+	{ST_OUT_WAIT_D,		EV_DLEST,		l4_do_dialout},
+	{ST_OUT_WAIT_D,		EV_DLRL,		l4_no_dchan},
+	{ST_OUT_WAIT_D,		EV_HANGUP,		l4_no_dchan},
+	{ST_IN_WAIT_D,		EV_DLEST,		l4_deliver_call},
+	{ST_IN_WAIT_D,		EV_DLRL,		l4_no_dchan_in},
+	{ST_IN_WAIT_D,		EV_HANGUP,		l4_no_dchan_in},
+	{ST_OUT_DIAL,		EV_SETUP_CNF,		l4_init_bchan_out},
+	{ST_OUT_DIAL,		EV_HANGUP,		l4_cancel_call},
+	{ST_OUT_DIAL,		EV_DISCONNECT_IND,	l4_received_d_disc},
+	{ST_OUT_DIAL,		EV_RELEASE_IND,		l4_received_d_rel},
+	{ST_OUT_DIAL,		EV_RELEASE_CNF,		l4_received_d_relcnf},
+	{ST_OUT_DIAL,		EV_NOSETUP_RSP,		l4_no_setup_rsp},
+	{ST_OUT_DIAL,		EV_SETUP_ERR,		l4_setup_err},
+	{ST_IN_WAIT_LL,		EV_SETUP_CMPL_IND,	l4_init_bchan_in},
+	{ST_IN_WAIT_LL,		EV_ACCEPTD,		l4_send_dconnect},
+	{ST_IN_WAIT_LL,		EV_HANGUP,		l4_reject_call},
+	{ST_IN_WAIT_LL,		EV_DISCONNECT_IND,	l4_received_d_disc},
+	{ST_IN_WAIT_LL,		EV_RELEASE_IND,		l4_received_d_rel},
+	{ST_IN_WAIT_LL,		EV_RELEASE_CNF,		l4_received_d_relcnf},
+	{ST_IN_ALERT_SEND,	EV_SETUP_CMPL_IND,	l4_init_bchan_in},
+	{ST_IN_ALERT_SEND,	EV_ACCEPTD,		l4_send_dconnect},
+	{ST_IN_ALERT_SEND,	EV_HANGUP,		l4_send_d_disc},
+	{ST_IN_ALERT_SEND,	EV_DISCONNECT_IND,	l4_received_d_disc},
+	{ST_IN_ALERT_SEND,	EV_RELEASE_IND,		l4_received_d_rel},
+	{ST_IN_ALERT_SEND,	EV_RELEASE_CNF,		l4_received_d_relcnf},
+	{ST_IN_WAIT_CONN_ACK,	EV_SETUP_CMPL_IND,	l4_init_bchan_in},
+	{ST_IN_WAIT_CONN_ACK,	EV_HANGUP,		l4_send_d_disc},
+	{ST_IN_WAIT_CONN_ACK,	EV_DISCONNECT_IND,	l4_received_d_disc},
+	{ST_IN_WAIT_CONN_ACK,	EV_RELEASE_IND,		l4_received_d_rel},
+	{ST_IN_WAIT_CONN_ACK,	EV_RELEASE_CNF,		l4_received_d_relcnf},
+	{ST_IN_WAIT_CONN_ACK,	EV_CONNECT_ERR,		l4_connect_err},
+	{ST_WAIT_BCONN,		EV_BC_EST,		l4_go_active},
+	{ST_WAIT_BCONN,		EV_BC_REL,		l4_send_d_disc},
+	{ST_WAIT_BCONN,		EV_HANGUP,		l4_send_d_disc},
+	{ST_WAIT_BCONN,		EV_DISCONNECT_IND,	l4_received_d_disc},
+	{ST_WAIT_BCONN,		EV_RELEASE_IND,		l4_received_d_rel},
+	{ST_WAIT_BCONN,		EV_RELEASE_CNF,		l4_received_d_relcnf},
+	{ST_ACTIVE,		EV_CINF,		l4_charge_info},
+	{ST_ACTIVE,		EV_BC_REL,		l4_released_bchan},
+	{ST_ACTIVE,		EV_HANGUP,		l4_disconn_bchan},
+	{ST_ACTIVE,		EV_DISCONNECT_IND,	l4_release_bchan},
+	{ST_ACTIVE,		EV_RELEASE_CNF,		l4_received_d_relcnf},
+	{ST_ACTIVE,		EV_RELEASE_IND,		l4_received_d_rel},
+	{ST_ACTIVE,		EV_DLRL,		l4_active_dlrl},
+	{ST_WAIT_BRELEASE,	EV_BC_REL,		l4_send_d_disc},
+	{ST_WAIT_BRELEASE,	EV_DISCONNECT_IND,	l4_received_d_disc},
+	{ST_WAIT_BRELEASE,	EV_RELEASE_CNF,		l4_received_d_relcnf},
+	{ST_WAIT_BRELEASE,	EV_RELEASE_IND,		l4_received_d_rel},
+	{ST_WAIT_BREL_DISC,	EV_BC_REL,		l4_received_d_disc},
+	{ST_WAIT_BREL_DISC,	EV_RELEASE_CNF,		l4_received_d_relcnf},
+	{ST_WAIT_BREL_DISC,	EV_RELEASE_IND,		l4_received_d_rel},
+	{ST_WAIT_DCOMMAND,	EV_HANGUP,		l4_send_d_disc},
+	{ST_WAIT_DCOMMAND,	EV_DISCONNECT_IND,	l4_received_d_disc},
+	{ST_WAIT_DCOMMAND,	EV_RELEASE_CNF,		l4_received_d_relcnf},
+	{ST_WAIT_DCOMMAND,	EV_RELEASE_IND,		l4_received_d_rel},
+	{ST_WAIT_DRELEASE,	EV_RELEASE_IND,		l4_timeout_d},
+	{ST_WAIT_DRELEASE,	EV_RELEASE_CNF,		l4_timeout_d},
+	{ST_WAIT_DRELEASE,	EV_RELEASE_ERR,		l4_timeout_d},
+	{ST_WAIT_DRELEASE,	EV_DIAL,		l4_no_dchan_ready},
+	{ST_WAIT_D_REL_CNF,	EV_RELEASE_CNF,		l4_timeout_d},
+	{ST_WAIT_D_REL_CNF,	EV_RELEASE_ERR,		l4_timeout_d},
+	{ST_WAIT_D_REL_CNF,	EV_DIAL,		l4_no_dchan_ready},
+	{ST_WAIT_DSHUTDOWN,	EV_DLRL,		l4_go_null},
+	{ST_WAIT_DSHUTDOWN,	EV_DIAL,		l4_prep_dialout},
+	{ST_WAIT_DSHUTDOWN,	EV_SETUP_IND,		l4_start_dchan},
+};
+/* *INDENT-ON* */
+
+
+
+
+#define FNCOUNT (sizeof(fnlist)/sizeof(struct FsmNode))
+
+static void
+lc_r1(struct FsmInst *fi, int event, void *arg)
+{
+	struct LcFsm *lf = fi->userdata;
+
+	FsmChangeState(fi, ST_LC_ACTIVATE_WAIT);
+	FsmAddTimer(&lf->act_timer, 1000, EV_LC_TIMER, NULL, 50);
+	lf->st->ma.manl1(lf->st, PH_ACTIVATE, NULL);
+
+}
+
+static void
+lc_r6(struct FsmInst *fi, int event, void *arg)
+{
+	struct LcFsm *lf = fi->userdata;
+
+	FsmDelTimer(&lf->act_timer, 50);
+	FsmChangeState(fi, ST_LC_DELAY);
+	FsmAddTimer(&lf->act_timer, 40, EV_LC_TIMER, NULL, 51);
+}
+
+static void
+lc_r2(struct FsmInst *fi, int event, void *arg)
+{
+	struct LcFsm *lf = fi->userdata;
+
+	if (lf->l2_establish) {
+		FsmChangeState(fi, ST_LC_ESTABLISH_WAIT);
+		if (lf->l2_start)
+			lf->st->ma.manl2(lf->st, DL_ESTABLISH, NULL);
+	} else {
+		FsmChangeState(fi, ST_LC_CONNECTED);
+		lf->lccall(lf, LC_ESTABLISH, NULL);
+	}
+}
+
+static void
+lc_r3(struct FsmInst *fi, int event, void *arg)
+{
+	struct LcFsm *lf = fi->userdata;
+
+	FsmChangeState(fi, ST_LC_CONNECTED);
+	lf->lccall(lf, LC_ESTABLISH, NULL);
+}
+
+static void
+lc_r7(struct FsmInst *fi, int event, void *arg)
+{
+	struct LcFsm *lf = fi->userdata;
+
+	FsmChangeState(fi, ST_LC_FLUSH_WAIT);
+	lf->st->ma.manl2(lf->st, DL_FLUSH, NULL);
+}
+
+static void
+lc_r4(struct FsmInst *fi, int event, void *arg)
+{
+	struct LcFsm *lf = fi->userdata;
+
+	if (lf->l2_establish) {
+		FsmChangeState(fi, ST_LC_RELEASE_WAIT);
+		lf->st->ma.manl2(lf->st, DL_RELEASE, NULL);
+		/* This timer is for releasing the channel even
+		 * there is a hang in layer 2 ; 5 sec are a try
+		 */
+		FsmAddTimer(&lf->act_timer, 5000, EV_LC_TIMER, NULL, 53);
+	} else {
+		FsmChangeState(fi, ST_LC_NULL);
+		lf->st->ma.manl1(lf->st, PH_DEACTIVATE, NULL);
+		lf->lccall(lf, LC_RELEASE, NULL);
+	}
+}
+
+static void
+lc_r4_1(struct FsmInst *fi, int event, void *arg)
+{
+	struct LcFsm *lf = fi->userdata;
+
+	FsmChangeState(fi, ST_LC_FLUSH_DELAY);
+	FsmAddTimer(&lf->act_timer, 50, EV_LC_TIMER, NULL, 52);
+}
+
+static void
+lc_r5_1(struct FsmInst *fi, int event, void *arg)
+{
+	struct LcFsm *lf = fi->userdata;
+
+	FsmChangeState(fi, ST_LC_RELEASE_WAIT);
+	/* This delay is needed for send out the UA frame before
+	 * PH_DEACTIVATE the interface
+	 */
+	FsmAddTimer(&lf->act_timer, 10, EV_LC_TIMER, NULL, 54);
+}
+
+static void
+lc_r5(struct FsmInst *fi, int event, void *arg)
+{
+	struct LcFsm *lf = fi->userdata;
+
+	FsmDelTimer(&lf->act_timer, 54);
+	FsmChangeState(fi, ST_LC_NULL);
+	lf->st->ma.manl1(lf->st, PH_DEACTIVATE, NULL);
+	lf->lccall(lf, LC_RELEASE, NULL);
+}
+/* *INDENT-OFF* */
+static struct FsmNode LcFnList[] =
+{
+	{ST_LC_NULL,  		EV_LC_ESTABLISH,	lc_r1},
+	{ST_LC_ACTIVATE_WAIT,	EV_LC_PH_ACTIVATE,	lc_r6},
+	{ST_LC_DELAY,		EV_LC_TIMER,		lc_r2},
+	{ST_LC_DELAY,		EV_LC_DL_ESTABLISH,	lc_r3},
+	{ST_LC_ESTABLISH_WAIT,	EV_LC_DL_ESTABLISH,	lc_r3},
+	{ST_LC_ESTABLISH_WAIT,	EV_LC_RELEASE,		lc_r5},
+	{ST_LC_CONNECTED,	EV_LC_FLUSH,		lc_r7},
+	{ST_LC_CONNECTED,	EV_LC_RELEASE,		lc_r4},
+	{ST_LC_CONNECTED,	EV_LC_DL_RELEASE,	lc_r5_1},
+	{ST_LC_FLUSH_WAIT,	EV_LC_DL_FLUSH,		lc_r4_1},
+	{ST_LC_FLUSH_DELAY,	EV_LC_TIMER,		lc_r4},
+	{ST_LC_RELEASE_WAIT,	EV_LC_DL_RELEASE,	lc_r5},
+	{ST_LC_RELEASE_WAIT,	EV_LC_TIMER,		lc_r5},
+	{ST_LC_ACTIVATE_WAIT,	EV_LC_TIMER,		lc_r5},
+	{ST_LC_ESTABLISH_WAIT,	EV_LC_DL_RELEASE,	lc_r5},
+};
+/* *INDENT-ON* */
+
+
+
+
+
+
+
+
+
+
+#define LC_FN_COUNT (sizeof(LcFnList)/sizeof(struct FsmNode))
+
+void
+CallcNew(void)
+{
+	callcfsm.state_count = STATE_COUNT;
+	callcfsm.event_count = EVENT_COUNT;
+	callcfsm.strEvent = strEvent;
+	callcfsm.strState = strState;
+	FsmNew(&callcfsm, fnlist, FNCOUNT);
+
+	lcfsm.state_count = LC_STATE_COUNT;
+	lcfsm.event_count = LC_EVENT_COUNT;
+	lcfsm.strEvent = strLcEvent;
+	lcfsm.strState = strLcState;
+	FsmNew(&lcfsm, LcFnList, LC_FN_COUNT);
+}
+
+void
+CallcFree(void)
+{
+	FsmFree(&lcfsm);
+	FsmFree(&callcfsm);
+}
+
+static void
+release_ds(struct Channel *chanp)
+{
+	struct PStack *st = &chanp->ds;
+	struct IsdnCardState *sp;
+	struct HscxState *hsp;
+
+	sp = st->l1.hardware;
+	hsp = sp->hs + chanp->hscx;
+
+	close_hscxstate(hsp);
+
+	switch (chanp->l2_active_protocol) {
+		case (ISDN_PROTO_L2_X75I):
+			releasestack_isdnl2(st);
+			break;
+		case (ISDN_PROTO_L2_HDLC):
+		case (ISDN_PROTO_L2_TRANS):
+			releasestack_transl2(st);
+			break;
+	}
+	/* Reset B-Channel Statemachine */
+	FsmDelTimer(&chanp->lc_b.act_timer, 79);
+	FsmChangeState(&chanp->lc_b.lcfi, ST_LC_NULL);
+}
+
+static void
+cc_l1man(struct PStack *st, int pr, void *arg)
+{
+	struct Channel *chanp = (struct Channel *) st->l4.userdata;
+
+	switch (pr) {
+		case (PH_ACTIVATE):
+			FsmEvent(&chanp->lc_d.lcfi, EV_LC_PH_ACTIVATE, NULL);
+			break;
+		case (PH_DEACTIVATE):
+			FsmEvent(&chanp->lc_d.lcfi, EV_LC_PH_DEACTIVATE, NULL);
+			break;
+	}
+}
+
+static void
+cc_l2man(struct PStack *st, int pr, void *arg)
+{
+	struct Channel *chanp = (struct Channel *) st->l4.userdata;
+
+	switch (pr) {
+		case (DL_ESTABLISH):
+			FsmEvent(&chanp->lc_d.lcfi, EV_LC_DL_ESTABLISH, NULL);
+			break;
+		case (DL_RELEASE):
+			FsmEvent(&chanp->lc_d.lcfi, EV_LC_DL_RELEASE, NULL);
+			break;
+		case (DL_FLUSH):
+			FsmEvent(&chanp->lc_d.lcfi, EV_LC_DL_FLUSH, NULL);
+			break;
+	}
+}
+
+static void
+dcc_l1man(struct PStack *st, int pr, void *arg)
+{
+	struct Channel *chanp = (struct Channel *) st->l4.userdata;
+
+	switch (pr) {
+		case (PH_ACTIVATE):
+			FsmEvent(&chanp->lc_b.lcfi, EV_LC_PH_ACTIVATE, NULL);
+			break;
+		case (PH_DEACTIVATE):
+			FsmEvent(&chanp->lc_b.lcfi, EV_LC_PH_DEACTIVATE, NULL);
+			break;
+	}
+}
+
+static void
+dcc_l2man(struct PStack *st, int pr, void *arg)
+{
+	struct Channel *chanp = (struct Channel *) st->l4.userdata;
+
+	switch (pr) {
+		case (DL_ESTABLISH):
+			FsmEvent(&chanp->lc_b.lcfi, EV_LC_DL_ESTABLISH, NULL);
+			break;
+		case (DL_RELEASE):
+			FsmEvent(&chanp->lc_b.lcfi, EV_LC_DL_RELEASE, NULL);
+			break;
+	}
+}
+
+static void
+l2tei_dummy(struct PStack *st, int pr, void *arg)
+{
+	struct Channel *chanp = (struct Channel *) st->l4.userdata;
+	char tmp[64], tm[32];
+
+	jiftime(tm, jiffies);
+	sprintf(tmp, "%s Channel %d Warning! Dummy l2tei called pr=%d\n", tm, chanp->chan, pr);
+	HiSax_putstatus(chanp->sp, tmp);
+}
+
+static void
+ll_handler(struct PStack *st, int pr, void *arg)
+{
+	struct Channel *chanp = (struct Channel *) st->l4.userdata;
+	char tmp[64], tm[32];
+
+	switch (pr) {
+		case (CC_DISCONNECT_IND):
+			FsmEvent(&chanp->fi, EV_DISCONNECT_IND, NULL);
+			break;
+		case (CC_RELEASE_CNF):
+			FsmEvent(&chanp->fi, EV_RELEASE_CNF, NULL);
+			break;
+		case (CC_SETUP_IND):
+			FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
+			break;
+		case (CC_RELEASE_IND):
+			FsmEvent(&chanp->fi, EV_RELEASE_IND, NULL);
+			break;
+		case (CC_SETUP_COMPLETE_IND):
+			FsmEvent(&chanp->fi, EV_SETUP_CMPL_IND, NULL);
+			break;
+		case (CC_SETUP_CNF):
+			FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
+			break;
+		case (CC_INFO_CHARGE):
+			FsmEvent(&chanp->fi, EV_CINF, NULL);
+			break;
+		case (CC_NOSETUP_RSP_ERR):
+			FsmEvent(&chanp->fi, EV_NOSETUP_RSP, NULL);
+			break;
+		case (CC_SETUP_ERR):
+			FsmEvent(&chanp->fi, EV_SETUP_ERR, NULL);
+			break;
+		case (CC_CONNECT_ERR):
+			FsmEvent(&chanp->fi, EV_CONNECT_ERR, NULL);
+			break;
+		case (CC_RELEASE_ERR):
+			FsmEvent(&chanp->fi, EV_RELEASE_ERR, NULL);
+			break;
+		default:
+			if (chanp->debug & 2048) {
+				jiftime(tm, jiffies);
+				sprintf(tmp, "%s Channel %d L3->L4 unknown primitiv %d\n",
+					tm, chanp->chan, pr);
+				HiSax_putstatus(chanp->sp, tmp);
+			}
+	}
+}
+
+static void
+init_is(struct Channel *chanp, unsigned int ces)
+{
+	struct PStack *st = &chanp->is;
+	struct IsdnCardState *sp = chanp->sp;
+	char tmp[128];
+
+	setstack_HiSax(st, sp);
+	st->l2.sap = 0;
+	st->l2.tei = 255;
+	st->l2.ces = ces;
+	st->l2.extended = !0;
+	st->l2.laptype = LAPD;
+	st->l2.window = 1;
+	st->l2.orig = !0;
+	st->l2.t200 = 1000;	/* 1000 milliseconds  */
+	if (st->protocol == ISDN_PTYPE_1TR6) {
+		st->l2.n200 = 3;	/* try 3 times        */
+		st->l2.t203 = 10000;	/* 10000 milliseconds */
+	} else {
+		st->l2.n200 = 4;	/* try 4 times        */
+		st->l2.t203 = 5000;	/* 5000 milliseconds  */
+	}
+	sprintf(tmp, "Channel %d q.921", chanp->chan);
+	setstack_isdnl2(st, tmp);
+	setstack_isdnl3(st, chanp);
+	st->l4.userdata = chanp;
+	st->l4.l2writewakeup = NULL;
+	st->l3.l3l4 = ll_handler;
+	st->l1.l1man = cc_l1man;
+	st->l2.l2man = cc_l2man;
+	st->pa = &chanp->para;
+	HiSax_addlist(sp, st);
+}
+
+static void
+callc_debug(struct FsmInst *fi, char *s)
+{
+	char str[80], tm[32];
+	struct Channel *chanp = fi->userdata;
+
+	jiftime(tm, jiffies);
+	sprintf(str, "%s Channel %d callc %s\n", tm, chanp->chan, s);
+	HiSax_putstatus(chanp->sp, str);
+}
+
+static void
+lc_debug(struct FsmInst *fi, char *s)
+{
+	char str[256], tm[32];
+	struct LcFsm *lf = fi->userdata;
+
+	jiftime(tm, jiffies);
+	sprintf(str, "%s Channel %d lc %s\n", tm, lf->ch->chan, s);
+	HiSax_putstatus(lf->ch->sp, str);
+}
+
+static void
+dlc_debug(struct FsmInst *fi, char *s)
+{
+	char str[256], tm[32];
+	struct LcFsm *lf = fi->userdata;
+
+	jiftime(tm, jiffies);
+	sprintf(str, "%s Channel %d dlc %s\n", tm, lf->ch->chan, s);
+	HiSax_putstatus(lf->ch->sp, str);
+}
+
+static void
+lccall_d(struct LcFsm *lf, int pr, void *arg)
+{
+	struct Channel *chanp = lf->ch;
+
+	switch (pr) {
+		case (LC_ESTABLISH):
+			FsmEvent(&chanp->fi, EV_DLEST, NULL);
+			break;
+		case (LC_RELEASE):
+			FsmEvent(&chanp->fi, EV_DLRL, NULL);
+			break;
+	}
+}
+
+static void
+lccall_b(struct LcFsm *lf, int pr, void *arg)
+{
+	struct Channel *chanp = lf->ch;
+
+	switch (pr) {
+		case (LC_ESTABLISH):
+			FsmEvent(&chanp->fi, EV_BC_EST, NULL);
+			break;
+		case (LC_RELEASE):
+			FsmEvent(&chanp->fi, EV_BC_REL, NULL);
+			break;
+	}
+}
+
+static void
+init_chan(int chan, struct IsdnCardState *csta, int hscx,
+	  unsigned int ces)
+{
+	struct Channel *chanp = csta->channel + chan;
+
+	chanp->sp = csta;
+	chanp->hscx = hscx;
+	chanp->chan = chan;
+	chanp->incoming = 0;
+	chanp->debug = 0;
+	chanp->Flags = 0;
+	chanp->leased = 0;
+	chanp->impair = 0;
+	init_is(chanp, ces);
+
+	chanp->fi.fsm = &callcfsm;
+	chanp->fi.state = ST_NULL;
+	chanp->fi.debug = 0;
+	chanp->fi.userdata = chanp;
+	chanp->fi.printdebug = callc_debug;
+	FsmInitTimer(&chanp->fi, &chanp->dial_timer);
+	FsmInitTimer(&chanp->fi, &chanp->drel_timer);
+
+	chanp->lc_d.lcfi.fsm = &lcfsm;
+	chanp->lc_d.lcfi.state = ST_LC_NULL;
+	chanp->lc_d.lcfi.debug = 0;
+	chanp->lc_d.lcfi.userdata = &chanp->lc_d;
+	chanp->lc_d.lcfi.printdebug = lc_debug;
+	chanp->lc_d.type = LC_D;
+	chanp->lc_d.ch = chanp;
+	chanp->lc_d.st = &chanp->is;
+	chanp->lc_d.l2_establish = !0;
+	chanp->lc_d.l2_start = !0;
+	chanp->lc_d.lccall = lccall_d;
+	FsmInitTimer(&chanp->lc_d.lcfi, &chanp->lc_d.act_timer);
+
+	chanp->lc_b.lcfi.fsm = &lcfsm;
+	chanp->lc_b.lcfi.state = ST_LC_NULL;
+	chanp->lc_b.lcfi.debug = 0;
+	chanp->lc_b.lcfi.userdata = &chanp->lc_b;
+	chanp->lc_b.lcfi.printdebug = dlc_debug;
+	chanp->lc_b.type = LC_B;
+	chanp->lc_b.ch = chanp;
+	chanp->lc_b.st = &chanp->ds;
+	chanp->lc_b.l2_establish = !0;
+	chanp->lc_b.l2_start = !0;
+	chanp->lc_b.lccall = lccall_b;
+	FsmInitTimer(&chanp->lc_b.lcfi, &chanp->lc_b.act_timer);
+	chanp->outcallref = 64;
+	chanp->data_open = 0;
+}
+
+int
+CallcNewChan(struct IsdnCardState *csta)
+{
+	int ces;
+
+	chancount += 2;
+	ces = randomces();
+	init_chan(0, csta, 1, ces++);
+	ces %= 0xffff;
+	init_chan(1, csta, 0, ces++);
+	printk(KERN_INFO "HiSax: 2 channels added\n");
+	return (2);
+}
+
+static void
+release_is(struct Channel *chanp)
+{
+	struct PStack *st = &chanp->is;
+
+	releasestack_isdnl2(st);
+	releasestack_isdnl3(st);
+	HiSax_rmlist(st->l1.hardware, st);
+}
+
+void
+CallcFreeChan(struct IsdnCardState *csta)
+{
+	int i;
+
+	for (i = 0; i < 2; i++) {
+		FsmDelTimer(&csta->channel[i].drel_timer, 74);
+		FsmDelTimer(&csta->channel[i].dial_timer, 75);
+		FsmDelTimer(&csta->channel[i].lc_b.act_timer, 76);
+		FsmDelTimer(&csta->channel[i].lc_d.act_timer, 77);
+		if (csta->channel[i].Flags & FLG_START_B) {
+			release_ds(csta->channel + i);
+		}
+		release_is(csta->channel + i);
+	}
+}
+
+static void
+lldata_handler(struct PStack *st, int pr, void *arg)
+{
+	struct Channel *chanp = (struct Channel *) st->l4.userdata;
+	struct sk_buff *skb = arg;
+
+	switch (pr) {
+		case (DL_DATA):
+			if (chanp->data_open)
+				chanp->sp->iif.rcvcallb_skb(chanp->sp->myid, chanp->chan, skb);
+			else {
+				SET_SKB_FREE(skb);
+				dev_kfree_skb(skb, FREE_READ);
+			}
+			break;
+		default:
+			printk(KERN_WARNING "lldata_handler unknown primitive %d\n",
+			       pr);
+			break;
+	}
+}
+
+static void
+lltrans_handler(struct PStack *st, int pr, void *arg)
+{
+	struct Channel *chanp = (struct Channel *) st->l4.userdata;
+	struct sk_buff *skb = arg;
+
+	switch (pr) {
+		case (PH_DATA):
+			if (chanp->data_open)
+				chanp->sp->iif.rcvcallb_skb(chanp->sp->myid, chanp->chan, skb);
+			else {
+				SET_SKB_FREE(skb);
+				dev_kfree_skb(skb, FREE_READ);
+			}
+			break;
+		default:
+			printk(KERN_WARNING "lltrans_handler unknown primitive %d\n",
+			       pr);
+			break;
+	}
+}
+
+static void
+ll_writewakeup(struct PStack *st)
+{
+	struct Channel *chanp = st->l4.userdata;
+	isdn_ctrl ic;
+
+	ic.driver = chanp->sp->myid;
+	ic.command = ISDN_STAT_BSENT;
+	ic.arg = chanp->chan;
+	chanp->sp->iif.statcallb(&ic);
+}
+
+static int
+init_ds(struct Channel *chanp, int incoming)
+{
+	struct PStack *st = &chanp->ds;
+	struct IsdnCardState *sp = chanp->sp;
+	struct HscxState *hsp = sp->hs + chanp->hscx;
+	char tmp[128];
+
+	st->l1.hardware = sp;
+
+	hsp->mode = 2;
+
+	if (setstack_hscx(st, hsp))
+		return (-1);
+
+	st->l2.extended = 0;
+	st->l2.laptype = LAPB;
+	st->l2.orig = !incoming;
+	st->l2.t200 = 1000;	/* 1000 milliseconds */
+	st->l2.window = 7;
+	st->l2.n200 = 4;	/* try 4 times       */
+	st->l2.t203 = 5000;	/* 5000 milliseconds */
+
+	st->l3.debug = 0;
+	switch (chanp->l2_active_protocol) {
+		case (ISDN_PROTO_L2_X75I):
+			sprintf(tmp, "Channel %d x.75", chanp->chan);
+			setstack_isdnl2(st, tmp);
+			st->l2.l2l3 = lldata_handler;
+			st->l1.l1man = dcc_l1man;
+			st->l2.l2man = dcc_l2man;
+			st->l2.l2tei = l2tei_dummy;
+			st->l4.userdata = chanp;
+			st->l4.l1writewakeup = NULL;
+			st->l4.l2writewakeup = ll_writewakeup;
+			st->l2.l2m.debug = chanp->debug & 16;
+			st->l2.debug = chanp->debug & 64;
+			st->ma.manl2(st, MDL_NOTEIPROC, NULL);
+			st->l1.hscxmode = 2;	/* Packet-Mode ? */
+			st->l1.hscxchannel = chanp->para.bchannel - 1;
+			break;
+		case (ISDN_PROTO_L2_HDLC):
+			st->l1.l1l2 = lltrans_handler;
+			st->l1.l1man = dcc_l1man;
+			st->l4.userdata = chanp;
+			st->l4.l1writewakeup = ll_writewakeup;
+			st->l1.hscxmode = 2;
+			st->l1.hscxchannel = chanp->para.bchannel - 1;
+			break;
+		case (ISDN_PROTO_L2_TRANS):
+			st->l1.l1l2 = lltrans_handler;
+			st->l1.l1man = dcc_l1man;
+			st->l4.userdata = chanp;
+			st->l4.l1writewakeup = ll_writewakeup;
+			st->l1.hscxmode = 1;
+			st->l1.hscxchannel = chanp->para.bchannel - 1;
+			break;
+	}
+	return (0);
+}
+
+static void
+channel_report(struct Channel *chanp)
+{
+}
+
+static void
+distr_debug(struct IsdnCardState *csta, int debugflags)
+{
+	int i;
+	struct Channel *chanp = csta->channel;
+
+	for (i = 0; i < 2; i++) {
+		chanp[i].debug = debugflags;
+		chanp[i].fi.debug = debugflags & 2;
+		chanp[i].is.l2.l2m.debug = debugflags & 8;
+		chanp[i].ds.l2.l2m.debug = debugflags & 16;
+		chanp[i].is.l2.debug = debugflags & 32;
+		chanp[i].ds.l2.debug = debugflags & 64;
+		chanp[i].lc_d.lcfi.debug = debugflags & 128;
+		chanp[i].lc_b.lcfi.debug = debugflags & 256;
+	}
+	csta->dlogflag = debugflags & 4;
+	csta->teistack->l2.l2m.debug = debugflags & 512;
+}
+
+int
+HiSax_command(isdn_ctrl * ic)
+{
+	struct IsdnCardState *csta = hisax_findcard(ic->driver);
+	struct Channel *chanp;
+	char tmp[128];
+	int i;
+	unsigned int num;
+
+	if (!csta) {
+		printk(KERN_ERR
+		"HiSax: if_command %d called with invalid driverId %d!\n",
+		       ic->command, ic->driver);
+		return -ENODEV;
+	}
+	switch (ic->command) {
+		case (ISDN_CMD_SETEAZ):
+			chanp = csta->channel + ic->arg;
+			if (chanp->debug & 1)
+				link_debug(chanp, "SETEAZ", 1);
+			break;
+		case (ISDN_CMD_SETL2):
+			chanp = csta->channel + (ic->arg & 0xff);
+			if (chanp->debug & 1) {
+				sprintf(tmp, "SETL2 card %d %ld", csta->cardnr + 1,
+					ic->arg >> 8);
+				link_debug(chanp, tmp, 1);
+			}
+			chanp->l2_protocol = ic->arg >> 8;
+			break;
+		case (ISDN_CMD_DIAL):
+			chanp = csta->channel + (ic->arg & 0xff);
+			if (chanp->debug & 1) {
+				sprintf(tmp, "DIAL %s -> %s (%d,%d)",
+					ic->parm.setup.eazmsn, ic->parm.setup.phone,
+				 ic->parm.setup.si1, ic->parm.setup.si2);
+				link_debug(chanp, tmp, 1);
+			}
+			chanp->para.setup = ic->parm.setup;
+			if (!strcmp(chanp->para.setup.eazmsn, "0"))
+				chanp->para.setup.eazmsn[0] = '\0';
+			/* this solution is dirty and may be change, if
+			 * we make a callreference based callmanager */
+			if (chanp->fi.state == ST_NULL) {
+				FsmEvent(&chanp->fi, EV_DIAL, NULL);
+			} else {
+				FsmDelTimer(&chanp->dial_timer, 70);
+				FsmAddTimer(&chanp->dial_timer, 50, EV_DIAL, NULL, 71);
+			}
+			break;
+		case (ISDN_CMD_ACCEPTB):
+			chanp = csta->channel + ic->arg;
+			if (chanp->debug & 1)
+				link_debug(chanp, "ACCEPTB", 1);
+			FsmEvent(&chanp->fi, EV_ACCEPTB, NULL);
+			break;
+		case (ISDN_CMD_ACCEPTD):
+			chanp = csta->channel + ic->arg;
+			if (chanp->debug & 1)
+				link_debug(chanp, "ACCEPTD", 1);
+			FsmEvent(&chanp->fi, EV_ACCEPTD, NULL);
+			break;
+		case (ISDN_CMD_HANGUP):
+			chanp = csta->channel + ic->arg;
+			if (chanp->debug & 1)
+				link_debug(chanp, "HANGUP", 1);
+			FsmEvent(&chanp->fi, EV_HANGUP, NULL);
+			break;
+		case (ISDN_CMD_SUSPEND):
+			chanp = csta->channel + ic->arg;
+			if (chanp->debug & 1) {
+				sprintf(tmp, "SUSPEND %s", ic->parm.num);
+				link_debug(chanp, tmp, 1);
+			}
+			FsmEvent(&chanp->fi, EV_SUSPEND, ic);
+			break;
+		case (ISDN_CMD_RESUME):
+			chanp = csta->channel + ic->arg;
+			if (chanp->debug & 1) {
+				sprintf(tmp, "RESUME %s", ic->parm.num);
+				link_debug(chanp, tmp, 1);
+			}
+			FsmEvent(&chanp->fi, EV_RESUME, ic);
+			break;
+		case (ISDN_CMD_LOCK):
+			HiSax_mod_inc_use_count();
+#ifdef MODULE
+			if (csta->channel[0].debug & 1024) {
+				jiftime(tmp, jiffies);
+				i = strlen(tmp);
+				sprintf(tmp + i, "   LOCK modcnt %lx\n", MOD_USE_COUNT);
+				HiSax_putstatus(csta, tmp);
+			}
+#endif				/* MODULE */
+			break;
+		case (ISDN_CMD_UNLOCK):
+			HiSax_mod_dec_use_count();
+#ifdef MODULE
+			if (csta->channel[0].debug & 1024) {
+				jiftime(tmp, jiffies);
+				i = strlen(tmp);
+				sprintf(tmp + i, " UNLOCK modcnt %lx\n", MOD_USE_COUNT);
+				HiSax_putstatus(csta, tmp);
+			}
+#endif				/* MODULE */
+			break;
+		case (ISDN_CMD_IOCTL):
+			switch (ic->arg) {
+				case (0):
+					HiSax_reportcard(csta->cardnr);
+					for (i = 0; i < 2; i++)
+						channel_report(&csta->channel[i]);
+					break;
+				case (1):
+					num = *(unsigned int *) ic->parm.num;
+					distr_debug(csta, num);
+					sprintf(tmp, "debugging flags card %d set to %x\n",
+						csta->cardnr + 1, num);
+					HiSax_putstatus(csta, tmp);
+					printk(KERN_DEBUG "HiSax: %s", tmp);
+					break;
+				case (2):
+					num = *(unsigned int *) ic->parm.num;
+					i = num >> 8;
+					if (i >= 2)
+						break;
+					chanp = csta->channel + i;
+					chanp->impair = num & 0xff;
+					if (chanp->debug & 1) {
+						sprintf(tmp, "IMPAIR %x", chanp->impair);
+						link_debug(chanp, tmp, 1);
+					}
+					break;
+				case (3):
+					for (i = 0; i < *(unsigned int *) ic->parm.num; i++)
+						HiSax_mod_dec_use_count();
+					break;
+				case (4):
+					for (i = 0; i < *(unsigned int *) ic->parm.num; i++)
+						HiSax_mod_inc_use_count();
+					break;
+				case (5):	/* set card in leased mode */
+					csta->channel[0].leased = 1;
+					csta->channel[1].leased = 1;
+					sprintf(tmp, "card %d set into leased mode\n",
+						csta->cardnr + 1);
+					HiSax_putstatus(csta, tmp);
+					break;
+#ifdef MODULE
+				case (55):
+#if (LINUX_VERSION_CODE < 0x020111)
+					MOD_USE_COUNT = MOD_VISITED;
+#else
+					MOD_USE_COUNT = 0;
+#endif
+					HiSax_mod_inc_use_count();
+					break;
+#endif				/* MODULE */
+				case (11):
+					csta->debug = *(unsigned int *) ic->parm.num;
+					sprintf(tmp, "l1 debugging flags card %d set to %x\n",
+					  csta->cardnr + 1, csta->debug);
+					HiSax_putstatus(cards[0].sp, tmp);
+					printk(KERN_DEBUG "HiSax: %s", tmp);
+					break;
+				case (13):
+					csta->channel[0].is.l3.debug = *(unsigned int *) ic->parm.num;
+					csta->channel[1].is.l3.debug = *(unsigned int *) ic->parm.num;
+					sprintf(tmp, "l3 debugging flags card %d set to %x\n",
+						csta->cardnr + 1, *(unsigned int *) ic->parm.num);
+					HiSax_putstatus(cards[0].sp, tmp);
+					printk(KERN_DEBUG "HiSax: %s", tmp);
+					break;
+				default:
+					printk(KERN_DEBUG "HiSax: invalid ioclt %d\n",
+					       (int) ic->arg);
+					return (-EINVAL);
+			}
+			break;
+		default:
+			break;
+	}
+
+	return (0);
+}
+
+int
+HiSax_writebuf_skb(int id, int chan, struct sk_buff *skb)
+{
+	struct IsdnCardState *csta = hisax_findcard(id);
+	struct Channel *chanp;
+	struct PStack *st;
+	int len = skb->len;
+	unsigned long flags;
+	struct sk_buff *nskb;
+	char tmp[64];
+
+	if (!csta) {
+		printk(KERN_ERR
+		    "HiSax: if_sendbuf called with invalid driverId!\n");
+		return -ENODEV;
+	}
+	chanp = csta->channel + chan;
+	st = &chanp->ds;
+	if (!chanp->data_open) {
+		link_debug(chanp, "writebuf: channel not open", 1);
+		return -EIO;
+	}
+	if (len > MAX_DATA_SIZE) {
+		sprintf(tmp, "writebuf: packet too large (%d bytes)", len);
+		printk(KERN_WARNING "HiSax_%s !\n", tmp);
+		link_debug(chanp, tmp, 1);
+		return -EINVAL;
+	}
+	if (len) {
+		if ((len + csta->hs[chanp->hscx].tx_cnt) > MAX_DATA_MEM) {
+			/* Must return 0 here, since this is not an error
+			 * but a temporary lack of resources.
+			 */
+			if (chanp->debug & 2048) {
+				sprintf(tmp, "writebuf: no buffers for %d bytes", len);
+				link_debug(chanp, tmp, 1);
+			}
+			return 0;
+		}
+		save_flags(flags);
+		cli();
+		nskb = skb_clone(skb, GFP_ATOMIC);
+		if (nskb) {
+			if (chanp->lc_b.l2_establish) {
+				csta->hs[chanp->hscx].tx_cnt += len + st->l2.ihsize;
+				chanp->ds.l3.l3l2(&chanp->ds, DL_DATA, nskb);
+			} else {
+				csta->hs[chanp->hscx].tx_cnt += len;
+				chanp->ds.l2.l2l1(&chanp->ds, PH_DATA, nskb);
+			}
+			dev_kfree_skb(skb, FREE_WRITE);
+		} else
+			len = 0;
+		restore_flags(flags);
+	}
+	return (len);
+}

FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen, slshen@lbl.gov