/* $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);
			}
			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);
			}
			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);
		} else
			len = 0;
		restore_flags(flags);
	}
	return (len);
}
