patch-2.0.36 linux/drivers/isdn/hisax/callc.c
Next file: linux/drivers/isdn/hisax/cert.c
Previous file: linux/drivers/isdn/hisax/avm_pci.c
Back to the patch index
Back to the overall index
- Lines: 3004
- Date:
Sun Nov 15 10:32:58 1998
- Orig file:
v2.0.35/linux/drivers/isdn/hisax/callc.c
- Orig date:
Mon Aug 4 17:34:00 1997
diff -u --recursive --new-file v2.0.35/linux/drivers/isdn/hisax/callc.c linux/drivers/isdn/hisax/callc.c
@@ -1,156 +1,146 @@
-/* $Id: callc.c,v 1.30 1997/05/29 10:40:43 keil Exp $
+/* $Id: callc.c,v 1.30.2.13 1998/11/05 21:13:32 keil Exp $
- * Author Karsten Keil (keil@temic-ech.spacenet.de)
+ * Author Karsten Keil (keil@isdn4linux.de)
* based on the teles driver from Jan den Ouden
*
+ * This file is (c) under GNU PUBLIC LICENSE
+ * For changes and modifications please read
+ * ../../../Documentation/isdn/HiSax.cert
+ *
* 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.30.2.13 1998/11/05 21:13:32 keil
+ * minor fixes
*
- * Revision 1.23 1997/03/04 23:07:42 keil
- * bugfix dial parameter
+ * Revision 1.30.2.12 1998/11/03 00:05:51 keil
+ * certification related changes
+ * fixed logging for smaller stack use
*
- * Revision 1.22 1997/02/27 13:51:55 keil
- * Reset B-channel (dlc) statemachine in every release
+ * Revision 1.30.2.11 1998/09/30 22:20:05 keil
+ * Cosmetics
*
- * Revision 1.21 1997/02/19 09:24:27 keil
- * Bugfix: Hangup to LL if a ttyI rings
+ * Revision 1.30.2.10 1998/09/27 13:05:35 keil
+ * Apply most changes from 2.1.X (HiSax 3.1)
*
- * Revision 1.20 1997/02/17 00:32:47 keil
- * Bugfix: No Busy reported to LL
+ * Revision 1.30.2.9 1998/05/27 18:04:53 keil
+ * HiSax 3.0
*
- * Revision 1.19 1997/02/14 12:23:10 fritz
- * Added support for new insmod parameter handling.
+ * Revision 1.30.2.8 1998/04/11 18:48:26 keil
+ * remove debug
*
- * Revision 1.18 1997/02/11 01:36:58 keil
- * Changed setup-interface (incoming and outgoing), cause reporting
+ * Revision 1.30.2.7 1998/04/08 21:51:50 keil
+ * new debug
*
- * 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.30.2.6 1998/03/07 23:15:02 tsbogend
+ * made HiSax working on Linux/Alpha
*
- * Revision 1.16 1997/01/27 23:17:03 keil
- * delete timers while unloading
+ * Revision 1.30.2.5 1998/02/09 11:24:17 keil
+ * New leased line support (Read README.HiSax!)
*
- * Revision 1.15 1997/01/27 16:00:38 keil
- * D-channel shutdown delay; improved callback
+ * Revision 1.30.2.4 1998/01/27 22:46:00 keil
+ * B-channel send delay now configurable
*
- * Revision 1.14 1997/01/21 22:16:39 keil
- * new statemachine; leased line support; cleanup for 2.0
+ * Revision 1.30.2.3 1998/01/11 23:21:03 keil
+ * Missing callc state
*
- * Revision 1.13 1996/12/08 19:51:17 keil
- * bugfixes from Pekka Sarnila
+ * Revision 1.30.2.2 1997/11/15 18:54:31 keil
+ * cosmetics
*
- * Revision 1.12 1996/11/26 20:20:03 keil
- * fixed warning while compile
+ * Revision 1.30.2.1 1997/10/17 22:13:32 keil
+ * update to last hisax version
*
- * Revision 1.11 1996/11/26 18:43:17 keil
- * change ioctl 555 --> 55 (555 didn't work)
+ * Revision 2.6 1997/09/11 17:26:58 keil
+ * Open B-channel if here are incomming packets
*
- * Revision 1.10 1996/11/26 18:06:07 keil
- * fixed missing break statement,ioctl 555 reset modcount
+ * Revision 2.5 1997/08/07 17:46:05 keil
+ * Fix Incomming Call without broadcast
*
- * Revision 1.9 1996/11/18 20:23:19 keil
- * log writebuf channel not open changed
+ * Revision 2.4 1997/08/03 14:37:58 keil
+ * Activate Layer2 in PtP mode
*
- * Revision 1.8 1996/11/06 17:43:17 keil
- * more changes for 2.1.X;block fixed ST_PRO_W
+ * Revision 2.3 1997/07/31 19:23:40 keil
+ * LAYER2_WATCHING for PtP
*
- * Revision 1.7 1996/11/06 15:13:51 keil
- * typo 0x64 --->64 in debug code
+ * Revision 2.2 1997/07/31 11:48:18 keil
+ * experimental REJECT after ALERTING
*
- * Revision 1.6 1996/11/05 19:40:33 keil
- * X.75 windowsize
+ * Revision 2.1 1997/07/30 17:12:59 keil
+ * more changes for 'One TEI per card'
*
- * Revision 1.5 1996/10/30 10:11:06 keil
- * debugging LOCK changed;ST_REL_W EV_HANGUP added
+ * Revision 2.0 1997/07/27 21:12:21 keil
+ * CRef based L3; new channel handling; many other stuff
*
- * Revision 1.4 1996/10/27 22:20:16 keil
- * alerting bugfixes
- * no static b-channel<->channel mapping
+ * Revision 1.31 1997/06/26 11:09:23 keil
+ * New managment and minor changes
*
- * 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
+ * old logs removed /KKe
*
*/
#define __NO_VERSION__
#include "hisax.h"
+#include "../avmb1/capicmd.h" /* this should be moved in a common place */
#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 $";
+const char *lli_revision = "$Revision: 1.30.2.13 $";
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 int init_b_st(struct Channel *chanp, int incoming);
+static void release_b_st(struct Channel *chanp);
static struct Fsm callcfsm =
-{NULL, 0, 0};
-static struct Fsm lcfsm =
-{NULL, 0, 0};
+{NULL, 0, 0, NULL, NULL};
static int chancount = 0;
-/* Flags for remembering action done in l4 */
+/* experimental REJECT after ALERTING for CALLBACK to beat the 4s delay */
+#define ALERT_REJECT 0
+
+/* Value to delay the sending of the first B-channel paket after CONNECT
+ * here is no value given by ITU, but experience shows that 300 ms will
+ * work on many networks, if you or your other side is behind local exchanges
+ * a greater value may be recommented. If the delay is to short the first paket
+ * will be lost and autodetect on many comercial routers goes wrong !
+ * You can adjust this value on runtime with
+ * hisaxctrl <id> 2 <value>
+ * value is in milliseconds
+ */
+#define DEFAULT_B_DELAY 300
-#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
+/* Flags for remembering action done in lli */
-#define SETBIT(flg, item) flg |= item
-#define RESBIT(flg, item) flg &= (~item)
+#define FLG_START_D 0
+#define FLG_ESTAB_D 1
+#define FLG_CALL_SEND 2
+#define FLG_CALL_REC 3
+#define FLG_CALL_ALERT 4
+#define FLG_START_B 5
+#define FLG_CONNECT_B 6
+#define FLG_LL_DCONN 7
+#define FLG_LL_BCONN 8
+#define FLG_DISC_SEND 9
+#define FLG_DISC_REC 10
+#define FLG_REL_REC 11
+#define FLG_DO_ALERT 12
+#define FLG_DO_HANGUP 13
+#define FLG_DO_CONNECT 14
+#define FLG_DO_ESTAB 15
+#define FLG_RESUME 16
/*
* Because of callback it's a good idea to delay the shutdown of the d-channel
*/
-#define DREL_TIMER_VALUE 30000
+#define DREL_TIMER_VALUE 40000
/*
* Find card with given driverId
@@ -162,21 +152,36 @@
int i;
for (i = 0; i < nrcards; i++)
- if (cards[i].sp)
- if (cards[i].sp->myid == driverid)
- return (cards[i].sp);
+ if (cards[i].cs)
+ if (cards[i].cs->myid == driverid)
+ return (cards[i].cs);
return (struct IsdnCardState *) 0;
}
+int
+discard_queue(struct sk_buff_head *q)
+{
+ struct sk_buff *skb;
+ int ret=0;
+
+ while ((skb = skb_dequeue(q))) {
+ dev_kfree_skb(skb, FREE_READ);
+ ret++;
+ }
+ return(ret);
+}
+
static void
-link_debug(struct Channel *chanp, char *s, int direction)
+link_debug(struct Channel *chanp, int direction, char *fmt, ...)
{
- char tmp[100], tm[32];
+ va_list args;
+ char tmp[16];
- 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);
+ va_start(args, fmt);
+ sprintf(tmp, "Ch%d %s ", chanp->chan,
+ direction ? "LL->HL" : "HL->LL");
+ VHiSax_putstatus(chanp->cs, tmp, fmt, args);
+ va_end(args);
}
@@ -233,7 +238,7 @@
EV_SETUP_CMPL_IND, /* 10 */
EV_BC_EST, /* 11 */
EV_WRITEBUF, /* 12 */
- EV_DATAIN, /* 13 */
+ EV_ESTABLISH, /* 13 */
EV_HANGUP, /* 14 */
EV_BC_REL, /* 15 */
EV_CINF, /* 16 */
@@ -263,7 +268,7 @@
"EV_SETUP_CMPL_IND",
"EV_BC_EST",
"EV_WRITEBUF",
- "EV_DATAIN",
+ "EV_ESTABLISH",
"EV_HANGUP",
"EV_BC_REL",
"EV_CINF",
@@ -276,1105 +281,1021 @@
"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[] =
+static inline void
+lli_deliver_cause(struct Channel *chanp, isdn_ctrl *ic)
{
- "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)
+ if (chanp->proc->para.cause < 0)
+ return;
+ ic->driver = chanp->cs->myid;
+ ic->command = ISDN_STAT_CAUSE;
+ ic->arg = chanp->chan;
+ if (chanp->cs->protocol == ISDN_PTYPE_EURO)
+ sprintf(ic->parm.num, "E%02X%02X", chanp->proc->para.loc & 0x7f,
+ chanp->proc->para.cause & 0x7f);
+ else
+ sprintf(ic->parm.num, "%02X%02X", chanp->proc->para.loc & 0x7f,
+ chanp->proc->para.cause & 0x7f);
+ chanp->cs->iif.statcallb(ic);
+}
-static char *strLcEvent[] =
+static void
+lli_d_established(struct FsmInst *fi, int event, void *arg)
{
- "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",
-};
+ struct Channel *chanp = fi->userdata;
-#define LC_D 0
-#define LC_B 1
+ test_and_set_bit(FLG_ESTAB_D, &chanp->Flags);
+ if (chanp->leased) {
+ isdn_ctrl ic;
+ int ret;
-static inline void
-l4_deliver_cause(struct Channel *chanp)
+ chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
+ FsmChangeState(fi, ST_IN_WAIT_LL);
+ test_and_set_bit(FLG_CALL_REC, &chanp->Flags);
+ if (chanp->debug & 1)
+ link_debug(chanp, 0, "STAT_ICALL_LEASED");
+ ic.driver = chanp->cs->myid;
+ ic.command = ISDN_STAT_ICALL;
+ ic.arg = chanp->chan;
+ ic.parm.setup.si1 = 7;
+ ic.parm.setup.si2 = 0;
+ ic.parm.setup.plan = 0;
+ ic.parm.setup.screen = 0;
+ sprintf(ic.parm.setup.eazmsn,"%d", chanp->chan + 1);
+ sprintf(ic.parm.setup.phone,"LEASED%d", chanp->cs->myid);
+ ret = chanp->cs->iif.statcallb(&ic);
+ if (chanp->debug & 1)
+ link_debug(chanp, 1, "statcallb ret=%d", ret);
+ if (!ret) {
+ chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
+ FsmChangeState(fi, ST_NULL);
+ }
+ } else if (fi->state == ST_WAIT_DSHUTDOWN)
+ FsmChangeState(fi, ST_NULL);
+}
+
+static void
+lli_d_released(struct FsmInst *fi, int event, void *arg)
{
- isdn_ctrl ic;
+ struct Channel *chanp = fi->userdata;
- 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);
+ test_and_clear_bit(FLG_START_D, &chanp->Flags);
}
/*
* Dial out
*/
static void
-l4_prep_dialout(struct FsmInst *fi, int event, void *arg)
+lli_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) {
+ if (test_bit(FLG_ESTAB_D, &chanp->Flags)) {
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);
+ chanp->Flags = 0;
+ if (EV_RESUME == event)
+ test_and_set_bit(FLG_RESUME, &chanp->Flags);
+ test_and_set_bit(FLG_START_D, &chanp->Flags);
+ chanp->d_st->lli.l4l3(chanp->d_st, DL_ESTABLISH | REQUEST, NULL);
}
}
static void
-l4_do_dialout(struct FsmInst *fi, int event, void *arg)
+lli_do_dialout(struct FsmInst *fi, int event, void *arg)
{
struct Channel *chanp = fi->userdata;
+ int ev;
FsmChangeState(fi, ST_OUT_DIAL);
+ chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
+ if (test_and_clear_bit(FLG_RESUME, &chanp->Flags))
+ ev = CC_RESUME | REQUEST;
+ else
+ ev = CC_SETUP | REQUEST;
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);
+ test_and_set_bit(FLG_ESTAB_D, &chanp->Flags);
+ chanp->d_st->lli.l4l3(chanp->d_st, ev, chanp);
+ test_and_set_bit(FLG_CALL_SEND, &chanp->Flags);
}
}
static void
-l4_init_bchan_out(struct FsmInst *fi, int event, void *arg)
+lli_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);
+ test_and_set_bit(FLG_LL_DCONN, &chanp->Flags);
if (chanp->debug & 1)
- link_debug(chanp, "STAT_DCONN", 0);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_DCONN");
+ ic.driver = chanp->cs->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);
+ chanp->cs->iif.statcallb(&ic);
+ init_b_st(chanp, 0);
+ test_and_set_bit(FLG_START_B, &chanp->Flags);
+ chanp->b_st->lli.l4l3(chanp->b_st, DL_ESTABLISH | REQUEST, NULL);
}
static void
-l4_go_active(struct FsmInst *fi, int event, void *arg)
+lli_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);
+ test_and_set_bit(FLG_CONNECT_B, &chanp->Flags);
if (chanp->debug & 1)
- link_debug(chanp, "STAT_BCONN", 0);
- SETBIT(chanp->Flags, FLG_LL_BCONN);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_BCONN");
+ test_and_set_bit(FLG_LL_BCONN, &chanp->Flags);
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_BCONN;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
+ chanp->cs->iif.statcallb(&ic);
+ chanp->cs->cardmsg(chanp->cs, MDL_INFO_CONN, (void *) (long)chanp->chan);
}
+/*
+ * RESUME
+ */
+
/* incomming call */
static void
-l4_start_dchan(struct FsmInst *fi, int event, void *arg)
+lli_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);
+ if (event == EV_ACCEPTD)
+ test_and_set_bit(FLG_DO_CONNECT, &chanp->Flags);
+ else if (event == EV_HANGUP) {
+ test_and_set_bit(FLG_DO_HANGUP, &chanp->Flags);
+#ifdef ALERT_REJECT
+ test_and_set_bit(FLG_DO_ALERT, &chanp->Flags);
+#endif
}
+ if (test_bit(FLG_ESTAB_D, &chanp->Flags)) {
+ FsmEvent(fi, EV_DLEST, NULL);
+ } else if (!test_and_set_bit(FLG_START_D, &chanp->Flags))
+ chanp->d_st->lli.l4l3(chanp->d_st, DL_ESTABLISH | REQUEST, NULL);
}
static void
-l4_deliver_call(struct FsmInst *fi, int event, void *arg)
+lli_deliver_call(struct FsmInst *fi, int event, void *arg)
{
struct Channel *chanp = fi->userdata;
isdn_ctrl ic;
int ret;
- char txt[32];
+ chanp->cs->cardmsg(chanp->cs, MDL_INFO_SETUP, (void *) (long)chanp->chan);
/*
* 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)) {
+ if (1) { /* for only one TEI */
FsmChangeState(fi, ST_IN_WAIT_LL);
- SETBIT(chanp->Flags, FLG_ESTAB_D);
- SETBIT(chanp->Flags, FLG_CALL_REC);
+ test_and_set_bit(FLG_CALL_REC, &chanp->Flags);
if (chanp->debug & 1)
- link_debug(chanp, "STAT_ICALL", 0);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_ICALL");
+ ic.driver = chanp->cs->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);
+ ic.parm.setup = chanp->proc->para.setup;
+ ret = chanp->cs->iif.statcallb(&ic);
+ if (chanp->debug & 1)
+ link_debug(chanp, 1, "statcallb ret=%d", ret);
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);
+ FsmDelTimer(&chanp->drel_timer, 61);
+ if (test_bit(FLG_ESTAB_D, &chanp->Flags)) {
+ FsmChangeState(fi, ST_IN_ALERT_SEND);
+ test_and_set_bit(FLG_CALL_ALERT, &chanp->Flags);
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
+ } else {
+ test_and_set_bit(FLG_DO_ALERT, &chanp->Flags);
+ FsmChangeState(fi, ST_IN_WAIT_D);
+ test_and_set_bit(FLG_START_D, &chanp->Flags);
+ chanp->d_st->lli.l4l3(chanp->d_st,
+ DL_ESTABLISH | REQUEST, NULL);
+ }
break;
case 2: /* Rejecting Call */
- RESBIT(chanp->Flags, FLG_CALL_REC);
+ test_and_clear_bit(FLG_CALL_REC, &chanp->Flags);
break;
case 0: /* OK, nobody likes this call */
default: /* statcallb problems */
- chanp->is.l4.l4l3(&chanp->is, CC_IGNORE, NULL);
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_IGNORE | REQUEST, chanp->proc);
+ chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
FsmChangeState(fi, ST_NULL);
- chanp->Flags = FLG_ESTAB_D;
- FsmAddTimer(&chanp->drel_timer, DREL_TIMER_VALUE, EV_SHUTDOWN_D, NULL, 61);
+ if (test_bit(FLG_ESTAB_D, &chanp->Flags) &&
+ !test_bit(FLG_PTP, &chanp->d_st->l2.flag))
+ FsmRestartTimer(&chanp->drel_timer, DREL_TIMER_VALUE, EV_SHUTDOWN_D, NULL, 61);
break;
}
} else {
- chanp->is.l4.l4l3(&chanp->is, CC_IGNORE, NULL);
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_IGNORE | REQUEST, chanp->proc);
+ chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
FsmChangeState(fi, ST_NULL);
- chanp->Flags = FLG_ESTAB_D;
- FsmAddTimer(&chanp->drel_timer, DREL_TIMER_VALUE, EV_SHUTDOWN_D, NULL, 62);
+ if (test_bit(FLG_ESTAB_D, &chanp->Flags) &&
+ !test_bit(FLG_PTP, &chanp->d_st->l2.flag))
+ FsmRestartTimer(&chanp->drel_timer, DREL_TIMER_VALUE, EV_SHUTDOWN_D, NULL, 62);
}
}
static void
-l4_send_dconnect(struct FsmInst *fi, int event, void *arg)
+lli_establish_d(struct FsmInst *fi, int event, void *arg)
+{
+ /* This establish the D-channel for pending L3 messages
+ * without blocking the channel
+ */
+ struct Channel *chanp = fi->userdata;
+
+ test_and_set_bit(FLG_DO_ESTAB, &chanp->Flags);
+ FsmChangeState(fi, ST_IN_WAIT_D);
+ test_and_set_bit(FLG_START_D, &chanp->Flags);
+ chanp->d_st->lli.l4l3(chanp->d_st, DL_ESTABLISH | REQUEST, NULL);
+}
+
+static void
+lli_do_action(struct FsmInst *fi, int event, void *arg)
+{
+ struct Channel *chanp = fi->userdata;
+
+ test_and_set_bit(FLG_ESTAB_D, &chanp->Flags);
+ if (chanp->leased) {
+ FsmChangeState(fi, ST_IN_WAIT_CONN_ACK);
+ test_and_clear_bit(FLG_DO_ALERT, &chanp->Flags);
+ test_and_clear_bit(FLG_DO_CONNECT, &chanp->Flags);
+ FsmEvent(&chanp->fi, EV_SETUP_CMPL_IND, NULL);
+ } else if (test_and_clear_bit(FLG_DO_CONNECT, &chanp->Flags) &&
+ !test_bit(FLG_DO_HANGUP, &chanp->Flags)) {
+ FsmChangeState(fi, ST_IN_WAIT_CONN_ACK);
+ test_and_clear_bit(FLG_DO_ALERT, &chanp->Flags);
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_SETUP | RESPONSE, chanp->proc);
+ } else if (test_and_clear_bit(FLG_DO_ALERT, &chanp->Flags)) {
+ if (test_bit(FLG_DO_HANGUP, &chanp->Flags))
+ FsmRestartTimer(&chanp->drel_timer, 40, EV_HANGUP, NULL, 63);
+ FsmChangeState(fi, ST_IN_ALERT_SEND);
+ test_and_set_bit(FLG_CALL_ALERT, &chanp->Flags);
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_ALERTING | REQUEST, chanp->proc);
+ } else if (test_and_clear_bit(FLG_DO_HANGUP, &chanp->Flags)) {
+ FsmChangeState(fi, ST_WAIT_DRELEASE);
+ chanp->proc->para.cause = 0x15; /* Call Rejected */
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_REJECT | REQUEST, chanp->proc);
+ test_and_set_bit(FLG_DISC_SEND, &chanp->Flags);
+ }
+}
+
+static void
+lli_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);
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_SETUP | RESPONSE, chanp->proc);
}
static void
-l4_init_bchan_in(struct FsmInst *fi, int event, void *arg)
+lli_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);
+ test_and_set_bit(FLG_LL_DCONN, &chanp->Flags);
if (chanp->debug & 1)
- link_debug(chanp, "STAT_DCONN", 0);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_DCONN");
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_DCONN;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
+ chanp->cs->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);
+ init_b_st(chanp, !0);
+ test_and_set_bit(FLG_START_B, &chanp->Flags);
+ chanp->b_st->lli.l4l3(chanp->b_st, DL_ESTABLISH | REQUEST, NULL);
}
-/* Call clearing */
+/* Call suspend */
static void
-l4_reject_call(struct FsmInst *fi, int event, void *arg)
+lli_suspend(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);
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_SUSPEND | REQUEST, chanp->proc);
}
+/* Call clearing */
+
static void
-l4_cancel_call(struct FsmInst *fi, int event, void *arg)
+lli_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 (test_and_clear_bit(FLG_LL_BCONN, &chanp->Flags)) {
if (chanp->debug & 1)
- link_debug(chanp, "STAT_BHUP", 0);
- RESBIT(chanp->Flags, FLG_LL_BCONN);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_BHUP");
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_BHUP;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
+ chanp->cs->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);
+ if (test_and_clear_bit(FLG_START_B, &chanp->Flags))
+ release_b_st(chanp);
+ chanp->proc->para.cause = 0x10; /* Normal Call Clearing */
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_DISCONNECT | REQUEST, chanp->proc);
+ test_and_set_bit(FLG_DISC_SEND, &chanp->Flags);
}
static void
-l4_shutdown_d(struct FsmInst *fi, int event, void *arg)
+lli_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);
+ if (test_bit(FLG_PTP, &chanp->d_st->l2.flag)) {
+ FsmChangeState(fi, ST_NULL);
+ } else {
+ if (!test_bit(FLG_TWO_DCHAN, &chanp->cs->HW_Flags)) {
+ if (chanp->chan) {
+ if (chanp->cs->channel[0].fi.state != ST_NULL)
+ return;
+ } else {
+ if (chanp->cs->channel[1].fi.state != ST_NULL)
+ return;
+ }
+ }
+ FsmChangeState(fi, ST_WAIT_DSHUTDOWN);
+ test_and_clear_bit(FLG_ESTAB_D, &chanp->Flags);
+ chanp->d_st->lli.l4l3(chanp->d_st, DL_RELEASE | REQUEST, NULL);
+ }
}
static void
-l4_timeout_d(struct FsmInst *fi, int event, void *arg)
+lli_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);
- }
+ test_and_clear_bit(FLG_LL_DCONN, &chanp->Flags);
+ if (chanp->debug & 1)
+ link_debug(chanp, 0, "STAT_DHUP");
+ lli_deliver_cause(chanp, &ic);
+ ic.driver = chanp->cs->myid;
+ ic.command = ISDN_STAT_DHUP;
+ ic.arg = chanp->chan;
+ chanp->cs->iif.statcallb(&ic);
FsmChangeState(fi, ST_NULL);
- chanp->Flags = FLG_ESTAB_D;
- FsmAddTimer(&chanp->drel_timer, DREL_TIMER_VALUE, EV_SHUTDOWN_D, NULL, 60);
+ chanp->Flags = 0;
+ test_and_set_bit(FLG_ESTAB_D, &chanp->Flags);
+ if (!test_bit(FLG_PTP, &chanp->d_st->l2.flag))
+ FsmAddTimer(&chanp->drel_timer, DREL_TIMER_VALUE, EV_SHUTDOWN_D, NULL, 60);
+ chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
}
static void
-l4_go_null(struct FsmInst *fi, int event, void *arg)
+lli_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);
+ chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
}
static void
-l4_disconn_bchan(struct FsmInst *fi, int event, void *arg)
+lli_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);
+ test_and_clear_bit(FLG_CONNECT_B, &chanp->Flags);
+ chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
}
static void
-l4_send_d_disc(struct FsmInst *fi, int event, void *arg)
+lli_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))
+ if (test_bit(FLG_DISC_REC, &chanp->Flags) ||
+ test_bit(FLG_REL_REC, &chanp->Flags))
return;
FsmChangeState(fi, ST_WAIT_DRELEASE);
- if (chanp->Flags & FLG_LL_BCONN) {
+ if (test_and_clear_bit(FLG_LL_BCONN, &chanp->Flags)) {
if (chanp->debug & 1)
- link_debug(chanp, "STAT_BHUP", 0);
- RESBIT(chanp->Flags, FLG_LL_BCONN);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_BHUP");
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_BHUP;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
+ chanp->cs->iif.statcallb(&ic);
}
- if (chanp->Flags & FLG_START_B) {
- release_ds(chanp);
- RESBIT(chanp->Flags, FLG_START_B);
+ if (test_and_clear_bit(FLG_START_B, &chanp->Flags))
+ release_b_st(chanp);
+ if (chanp->leased) {
+ ic.command = ISDN_STAT_CAUSE;
+ ic.arg = chanp->chan;
+ sprintf(ic.parm.num, "L0010");
+ chanp->cs->iif.statcallb(&ic);
+ if (chanp->debug & 1)
+ link_debug(chanp, 0, "STAT_DHUP");
+ ic.driver = chanp->cs->myid;
+ ic.command = ISDN_STAT_DHUP;
+ ic.arg = chanp->chan;
+ chanp->cs->iif.statcallb(&ic);
+ FsmChangeState(fi, ST_WAIT_DSHUTDOWN);
+ test_and_clear_bit(FLG_ESTAB_D, &chanp->Flags);
+ chanp->d_st->lli.l4l3(chanp->d_st, DL_RELEASE | REQUEST, NULL);
+ } else {
+ if (test_and_clear_bit(FLG_DO_HANGUP, &chanp->Flags))
+ chanp->proc->para.cause = 0x15; /* Call Reject */
+ else
+ chanp->proc->para.cause = 0x10; /* Normal Call Clearing */
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_DISCONNECT | REQUEST, chanp->proc);
+ test_and_set_bit(FLG_DISC_SEND, &chanp->Flags);
}
- 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)
+lli_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 (test_and_clear_bit(FLG_LL_BCONN, &chanp->Flags)) {
if (chanp->debug & 1)
- link_debug(chanp, "STAT_BHUP", 0);
- RESBIT(chanp->Flags, FLG_LL_BCONN);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_BHUP");
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_BHUP;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
+ chanp->cs->iif.statcallb(&ic);
}
- release_ds(chanp);
- RESBIT(chanp->Flags, FLG_START_B);
+ release_b_st(chanp);
+ test_and_clear_bit(FLG_START_B, &chanp->Flags);
}
static void
-l4_release_bchan(struct FsmInst *fi, int event, void *arg)
+lli_release_bchan(struct FsmInst *fi, int event, void *arg)
{
struct Channel *chanp = fi->userdata;
chanp->data_open = 0;
- SETBIT(chanp->Flags, FLG_DISC_REC);
+ test_and_set_bit(FLG_DISC_REC, &chanp->Flags);
FsmChangeState(fi, ST_WAIT_BREL_DISC);
- RESBIT(chanp->Flags, FLG_CONNECT_B);
- FsmEvent(&chanp->lc_b.lcfi, EV_LC_RELEASE, NULL);
+ test_and_clear_bit(FLG_CONNECT_B, &chanp->Flags);
+ chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
}
static void
-l4_received_d_rel(struct FsmInst *fi, int event, void *arg)
+lli_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);
+ FsmChangeState(fi, ST_NULL);
+ test_and_set_bit(FLG_REL_REC, &chanp->Flags);
+ if (test_and_clear_bit(FLG_CONNECT_B, &chanp->Flags)) {
+ chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
}
- if (chanp->Flags & FLG_LL_BCONN) {
+ if (test_and_clear_bit(FLG_LL_BCONN, &chanp->Flags)) {
if (chanp->debug & 1)
- link_debug(chanp, "STAT_BHUP", 0);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_BHUP");
+ ic.driver = chanp->cs->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);
+ chanp->cs->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);
+ if (test_and_clear_bit(FLG_START_B, &chanp->Flags))
+ release_b_st(chanp);
+ if (chanp->debug & 1)
+ link_debug(chanp, 0, "STAT_DHUP");
+ lli_deliver_cause(chanp, &ic);
+ ic.driver = chanp->cs->myid;
+ ic.command = ISDN_STAT_DHUP;
+ ic.arg = chanp->chan;
+ chanp->cs->iif.statcallb(&ic);
+ test_and_clear_bit(FLG_DISC_SEND, &chanp->Flags);
+ test_and_clear_bit(FLG_CALL_REC, &chanp->Flags);
+ test_and_clear_bit(FLG_CALL_ALERT, &chanp->Flags);
+ test_and_clear_bit(FLG_LL_DCONN, &chanp->Flags);
+ test_and_clear_bit(FLG_CALL_SEND, &chanp->Flags);
+ lli_timeout_d(fi, event, arg);
}
static void
-l4_received_d_relcnf(struct FsmInst *fi, int event, void *arg)
+lli_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);
+ FsmChangeState(fi, ST_NULL);
+ if (test_and_clear_bit(FLG_CONNECT_B, &chanp->Flags)) {
+ chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
}
- if (chanp->Flags & FLG_LL_BCONN) {
+ if (test_and_clear_bit(FLG_LL_BCONN, &chanp->Flags)) {
if (chanp->debug & 1)
- link_debug(chanp, "STAT_BHUP", 0);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_BHUP");
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_BHUP;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
- RESBIT(chanp->Flags, FLG_LL_BCONN);
+ chanp->cs->iif.statcallb(&ic);
}
- 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);
+ if (test_and_clear_bit(FLG_START_B, &chanp->Flags))
+ release_b_st(chanp);
+ if (chanp->debug & 1)
+ link_debug(chanp, 0, "STAT_DHUP");
+ lli_deliver_cause(chanp, &ic);
+ ic.driver = chanp->cs->myid;
+ ic.command = ISDN_STAT_DHUP;
+ ic.arg = chanp->chan;
+ chanp->cs->iif.statcallb(&ic);
+ test_and_clear_bit(FLG_DISC_SEND, &chanp->Flags);
+ test_and_clear_bit(FLG_CALL_REC, &chanp->Flags);
+ test_and_clear_bit(FLG_CALL_ALERT, &chanp->Flags);
+ test_and_clear_bit(FLG_LL_DCONN, &chanp->Flags);
+ test_and_clear_bit(FLG_CALL_SEND, &chanp->Flags);
+ lli_timeout_d(fi, event, arg);
}
static void
-l4_received_d_disc(struct FsmInst *fi, int event, void *arg)
+lli_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) {
+ test_and_set_bit(FLG_DISC_REC, &chanp->Flags);
+ if (test_and_clear_bit(FLG_LL_BCONN, &chanp->Flags)) {
if (chanp->debug & 1)
- link_debug(chanp, "STAT_BHUP", 0);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_BHUP");
+ ic.driver = chanp->cs->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);
+ chanp->cs->iif.statcallb(&ic);
}
- 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);
+ if (test_and_clear_bit(FLG_START_B, &chanp->Flags))
+ release_b_st(chanp);
+ if (chanp->debug & 1)
+ link_debug(chanp, 0, "STAT_DHUP");
+ lli_deliver_cause(chanp, &ic);
+ ic.driver = chanp->cs->myid;
+ ic.command = ISDN_STAT_DHUP;
+ ic.arg = chanp->chan;
+ chanp->cs->iif.statcallb(&ic);
+ test_and_clear_bit(FLG_CALL_ALERT, &chanp->Flags);
+ test_and_clear_bit(FLG_LL_DCONN, &chanp->Flags);
+ test_and_clear_bit(FLG_CALL_SEND, &chanp->Flags);
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_RELEASE | REQUEST, chanp->proc);
}
/* processing charge info */
static void
-l4_charge_info(struct FsmInst *fi, int event, void *arg)
+lli_charge_info(struct FsmInst *fi, int event, void *arg)
{
struct Channel *chanp = fi->userdata;
isdn_ctrl ic;
- ic.driver = chanp->sp->myid;
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_CINF;
ic.arg = chanp->chan;
- sprintf(ic.parm.num, "%d", chanp->para.chargeinfo);
- chanp->sp->iif.statcallb(&ic);
+ sprintf(ic.parm.num, "%d", chanp->proc->para.chargeinfo);
+ chanp->cs->iif.statcallb(&ic);
}
/* error procedures */
static void
-l4_no_dchan(struct FsmInst *fi, int event, void *arg)
+lli_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;
+ link_debug(chanp, 0, "STAT_NODCH");
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_NODCH;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
+ chanp->cs->iif.statcallb(&ic);
chanp->Flags = 0;
FsmChangeState(fi, ST_NULL);
- FsmEvent(&chanp->lc_d.lcfi, EV_LC_RELEASE, NULL);
+ chanp->d_st->lli.l4l3(chanp->d_st, DL_RELEASE | REQUEST, NULL);
}
static void
-l4_no_dchan_ready(struct FsmInst *fi, int event, void *arg)
+lli_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;
+ link_debug(chanp, 0, "STAT_DHUP");
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_DHUP;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
+ chanp->cs->iif.statcallb(&ic);
}
static void
-l4_no_dchan_in(struct FsmInst *fi, int event, void *arg)
+lli_no_dchan_in(struct FsmInst *fi, int event, void *arg)
{
struct Channel *chanp = fi->userdata;
+ isdn_ctrl ic;
- chanp->is.l4.l4l3(&chanp->is, CC_DLRL, NULL);
+ if (chanp->debug & 1)
+ link_debug(chanp, 0, "STAT_DHUP");
+ ic.driver = chanp->cs->myid;
+ ic.command = ISDN_STAT_DHUP;
+ ic.arg = chanp->chan;
+ chanp->cs->iif.statcallb(&ic);
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_DLRL | REQUEST, chanp->proc);
chanp->Flags = 0;
FsmChangeState(fi, ST_NULL);
- FsmEvent(&chanp->lc_d.lcfi, EV_LC_RELEASE, NULL);
+ chanp->d_st->lli.l4l3(chanp->d_st, DL_RELEASE | REQUEST, NULL);
}
static void
-l4_no_setup_rsp(struct FsmInst *fi, int event, void *arg)
+lli_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);
+ test_and_clear_bit(FLG_CALL_SEND, &chanp->Flags);
if (chanp->debug & 1)
- link_debug(chanp, "STAT_DHUP", 0);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_DHUP");
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_DHUP;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
+ chanp->cs->iif.statcallb(&ic);
+ lli_shutdown_d(fi, event, arg);
}
static void
-l4_setup_err(struct FsmInst *fi, int event, void *arg)
+lli_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 */
+ test_and_clear_bit(FLG_LL_DCONN, &chanp->Flags);
+ if (chanp->debug & 1)
+ link_debug(chanp, 0, "STAT_DHUP");
+ lli_deliver_cause(chanp, &ic);
+ ic.driver = chanp->cs->myid;
+ ic.command = ISDN_STAT_DHUP;
+ ic.arg = chanp->chan;
+ chanp->cs->iif.statcallb(&ic);
+ test_and_set_bit(FLG_DISC_SEND, &chanp->Flags); /* DISCONN was sent from L3 */
}
static void
-l4_connect_err(struct FsmInst *fi, int event, void *arg)
+lli_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 */
+ test_and_clear_bit(FLG_LL_DCONN, &chanp->Flags);
+ if (chanp->debug & 1)
+ link_debug(chanp, 0, "STAT_DHUP");
+ lli_deliver_cause(chanp, &ic);
+ ic.driver = chanp->cs->myid;
+ ic.command = ISDN_STAT_DHUP;
+ ic.arg = chanp->chan;
+ chanp->cs->iif.statcallb(&ic);
+ test_and_set_bit(FLG_DISC_SEND, &chanp->Flags); /* DISCONN was sent from L3 */
}
static void
-l4_active_dlrl(struct FsmInst *fi, int event, void *arg)
+lli_got_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 (test_and_clear_bit(FLG_CONNECT_B, &chanp->Flags)) {
+ chanp->b_st->lli.l4l3(chanp->b_st, DL_RELEASE | REQUEST, NULL);
}
- if (chanp->Flags & FLG_LL_BCONN) {
+ if (test_and_clear_bit(FLG_LL_BCONN, &chanp->Flags)) {
if (chanp->debug & 1)
- link_debug(chanp, "STAT_BHUP", 0);
- ic.driver = chanp->sp->myid;
+ link_debug(chanp, 0, "STAT_BHUP");
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_BHUP;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
- RESBIT(chanp->Flags, FLG_LL_BCONN);
+ chanp->cs->iif.statcallb(&ic);
}
- if (chanp->Flags & FLG_START_B) {
- release_ds(chanp);
- RESBIT(chanp->Flags, FLG_START_B);
- }
- if (chanp->Flags & FLG_LL_DCONN) {
+ if (test_and_clear_bit(FLG_START_B, &chanp->Flags))
+ release_b_st(chanp);
+ if (chanp->leased) {
+ ic.driver = chanp->cs->myid;
+ ic.command = ISDN_STAT_CAUSE;
+ ic.arg = chanp->chan;
+ sprintf(ic.parm.num, "L%02X%02X", 0, 0x2f);
+ chanp->cs->iif.statcallb(&ic);
+ ic.driver = chanp->cs->myid;
+ ic.command = ISDN_STAT_DHUP;
+ ic.arg = chanp->chan;
+ chanp->cs->iif.statcallb(&ic);
+ chanp->Flags = 0;
+ } else {
+ test_and_clear_bit(FLG_LL_DCONN, &chanp->Flags);
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;
+ link_debug(chanp, 0, "STAT_DHUP");
+ if (chanp->cs->protocol == ISDN_PTYPE_EURO) {
+ chanp->proc->para.cause = 0x2f;
+ chanp->proc->para.loc = 0;
} else {
- chanp->para.cause = 0x70;
- chanp->para.loc = 0;
+ chanp->proc->para.cause = 0x70;
+ chanp->proc->para.loc = 0;
}
- l4_deliver_cause(chanp);
- ic.driver = chanp->sp->myid;
+ lli_deliver_cause(chanp, &ic);
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_DHUP;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
+ chanp->cs->iif.statcallb(&ic);
+ chanp->d_st->lli.l4l3(chanp->d_st, CC_DLRL | REQUEST, chanp->proc);
+ chanp->Flags = 0;
+ chanp->d_st->lli.l4l3(chanp->d_st, DL_RELEASE | REQUEST, NULL);
}
- 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);
+ chanp->cs->cardmsg(chanp->cs, MDL_INFO_REL, (void *) (long)chanp->chan);
}
-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[] =
+static struct FsmNode fnlist[] HISAX_INITDATA =
{
- {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},
+ {ST_NULL, EV_DIAL, lli_prep_dialout},
+ {ST_NULL, EV_RESUME, lli_prep_dialout},
+ {ST_NULL, EV_SETUP_IND, lli_deliver_call},
+ {ST_NULL, EV_SHUTDOWN_D, lli_shutdown_d},
+ {ST_NULL, EV_DLRL, lli_go_null},
+ {ST_NULL, EV_DLEST, lli_d_established},
+ {ST_NULL, EV_ESTABLISH, lli_establish_d},
+ {ST_OUT_WAIT_D, EV_DLEST, lli_do_dialout},
+ {ST_OUT_WAIT_D, EV_DLRL, lli_no_dchan},
+ {ST_OUT_WAIT_D, EV_HANGUP, lli_no_dchan},
+ {ST_IN_WAIT_D, EV_DLEST, lli_do_action},
+ {ST_IN_WAIT_D, EV_DLRL, lli_no_dchan_in},
+ {ST_IN_WAIT_D, EV_ACCEPTD, lli_start_dchan},
+ {ST_IN_WAIT_D, EV_HANGUP, lli_start_dchan},
+ {ST_OUT_DIAL, EV_SETUP_CNF, lli_init_bchan_out},
+ {ST_OUT_DIAL, EV_HANGUP, lli_cancel_call},
+ {ST_OUT_DIAL, EV_DISCONNECT_IND, lli_received_d_disc},
+ {ST_OUT_DIAL, EV_RELEASE_IND, lli_received_d_rel},
+ {ST_OUT_DIAL, EV_RELEASE_CNF, lli_received_d_relcnf},
+ {ST_OUT_DIAL, EV_NOSETUP_RSP, lli_no_setup_rsp},
+ {ST_OUT_DIAL, EV_SETUP_ERR, lli_setup_err},
+ {ST_OUT_DIAL, EV_DLRL, lli_got_dlrl},
+ {ST_IN_WAIT_LL, EV_DLEST, lli_d_established},
+ {ST_IN_WAIT_LL, EV_DLRL, lli_d_released},
+ {ST_IN_WAIT_LL, EV_ACCEPTD, lli_start_dchan},
+ {ST_IN_WAIT_LL, EV_HANGUP, lli_start_dchan},
+ {ST_IN_WAIT_LL, EV_DISCONNECT_IND, lli_received_d_disc},
+ {ST_IN_WAIT_LL, EV_RELEASE_IND, lli_received_d_rel},
+ {ST_IN_WAIT_LL, EV_RELEASE_CNF, lli_received_d_relcnf},
+ {ST_IN_ALERT_SEND, EV_SETUP_CMPL_IND, lli_init_bchan_in},
+ {ST_IN_ALERT_SEND, EV_ACCEPTD, lli_send_dconnect},
+ {ST_IN_ALERT_SEND, EV_HANGUP, lli_send_d_disc},
+ {ST_IN_ALERT_SEND, EV_DISCONNECT_IND, lli_received_d_disc},
+ {ST_IN_ALERT_SEND, EV_RELEASE_IND, lli_received_d_rel},
+ {ST_IN_ALERT_SEND, EV_RELEASE_CNF, lli_received_d_relcnf},
+ {ST_IN_ALERT_SEND, EV_DLRL, lli_got_dlrl},
+ {ST_IN_WAIT_CONN_ACK, EV_SETUP_CMPL_IND, lli_init_bchan_in},
+ {ST_IN_WAIT_CONN_ACK, EV_HANGUP, lli_send_d_disc},
+ {ST_IN_WAIT_CONN_ACK, EV_DISCONNECT_IND, lli_received_d_disc},
+ {ST_IN_WAIT_CONN_ACK, EV_RELEASE_IND, lli_received_d_rel},
+ {ST_IN_WAIT_CONN_ACK, EV_RELEASE_CNF, lli_received_d_relcnf},
+ {ST_IN_WAIT_CONN_ACK, EV_CONNECT_ERR, lli_connect_err},
+ {ST_IN_WAIT_CONN_ACK, EV_DLRL, lli_got_dlrl},
+ {ST_WAIT_BCONN, EV_BC_EST, lli_go_active},
+ {ST_WAIT_BCONN, EV_BC_REL, lli_send_d_disc},
+ {ST_WAIT_BCONN, EV_HANGUP, lli_send_d_disc},
+ {ST_WAIT_BCONN, EV_DISCONNECT_IND, lli_received_d_disc},
+ {ST_WAIT_BCONN, EV_RELEASE_IND, lli_received_d_rel},
+ {ST_WAIT_BCONN, EV_RELEASE_CNF, lli_received_d_relcnf},
+ {ST_WAIT_BCONN, EV_DLRL, lli_got_dlrl},
+ {ST_WAIT_BCONN, EV_CINF, lli_charge_info},
+ {ST_ACTIVE, EV_CINF, lli_charge_info},
+ {ST_ACTIVE, EV_BC_REL, lli_released_bchan},
+ {ST_ACTIVE, EV_SUSPEND, lli_suspend},
+ {ST_ACTIVE, EV_HANGUP, lli_disconn_bchan},
+ {ST_ACTIVE, EV_DISCONNECT_IND, lli_release_bchan},
+ {ST_ACTIVE, EV_RELEASE_CNF, lli_received_d_relcnf},
+ {ST_ACTIVE, EV_RELEASE_IND, lli_received_d_rel},
+ {ST_ACTIVE, EV_DLRL, lli_got_dlrl},
+ {ST_WAIT_BRELEASE, EV_BC_REL, lli_send_d_disc},
+ {ST_WAIT_BRELEASE, EV_DISCONNECT_IND, lli_received_d_disc},
+ {ST_WAIT_BRELEASE, EV_RELEASE_CNF, lli_received_d_relcnf},
+ {ST_WAIT_BRELEASE, EV_RELEASE_IND, lli_received_d_rel},
+ {ST_WAIT_BRELEASE, EV_DLRL, lli_got_dlrl},
+ {ST_WAIT_BREL_DISC, EV_BC_REL, lli_received_d_disc},
+ {ST_WAIT_BREL_DISC, EV_RELEASE_CNF, lli_received_d_relcnf},
+ {ST_WAIT_BREL_DISC, EV_RELEASE_IND, lli_received_d_rel},
+ {ST_WAIT_BREL_DISC, EV_DLRL, lli_got_dlrl},
+ {ST_WAIT_DCOMMAND, EV_HANGUP, lli_send_d_disc},
+ {ST_WAIT_DCOMMAND, EV_DISCONNECT_IND, lli_received_d_disc},
+ {ST_WAIT_DCOMMAND, EV_RELEASE_CNF, lli_received_d_relcnf},
+ {ST_WAIT_DCOMMAND, EV_RELEASE_IND, lli_received_d_rel},
+ {ST_WAIT_DCOMMAND, EV_DLRL, lli_got_dlrl},
+ {ST_WAIT_DRELEASE, EV_RELEASE_IND, lli_timeout_d},
+ {ST_WAIT_DRELEASE, EV_RELEASE_CNF, lli_timeout_d},
+ {ST_WAIT_DRELEASE, EV_RELEASE_ERR, lli_timeout_d},
+ {ST_WAIT_DRELEASE, EV_DIAL, lli_no_dchan_ready},
+ {ST_WAIT_DRELEASE, EV_DLRL, lli_got_dlrl},
+ {ST_WAIT_D_REL_CNF, EV_RELEASE_CNF, lli_timeout_d},
+ {ST_WAIT_D_REL_CNF, EV_RELEASE_ERR, lli_timeout_d},
+/* ETS 300-104 16.1 */
+ {ST_WAIT_D_REL_CNF, EV_RELEASE_IND, lli_timeout_d},
+ {ST_WAIT_D_REL_CNF, EV_DIAL, lli_no_dchan_ready},
+ {ST_WAIT_D_REL_CNF, EV_DLRL, lli_got_dlrl},
+ {ST_WAIT_DSHUTDOWN, EV_DLRL, lli_go_null},
+ {ST_WAIT_DSHUTDOWN, EV_DLEST, lli_d_established},
+ {ST_WAIT_DSHUTDOWN, EV_DIAL, lli_prep_dialout},
+ {ST_WAIT_DSHUTDOWN, EV_RESUME, lli_prep_dialout},
+ {ST_WAIT_DSHUTDOWN, EV_SETUP_IND, lli_deliver_call},
};
/* *INDENT-ON* */
+#define FNCOUNT (sizeof(fnlist)/sizeof(struct FsmNode))
-
-
-
-
-
-
-
-#define LC_FN_COUNT (sizeof(LcFnList)/sizeof(struct FsmNode))
-
-void
-CallcNew(void)
+HISAX_INITFUNC(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)
+release_b_st(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);
+ struct PStack *st = chanp->b_st;
+ chanp->bcs->BC_Close(chanp->bcs);
switch (chanp->l2_active_protocol) {
case (ISDN_PROTO_L2_X75I):
releasestack_isdnl2(st);
break;
case (ISDN_PROTO_L2_HDLC):
case (ISDN_PROTO_L2_TRANS):
+// case (ISDN_PROTO_L2_MODEM):
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
+*selectfreechannel(struct PStack *st)
{
- struct Channel *chanp = (struct Channel *) st->l4.userdata;
+ struct IsdnCardState *cs = st->l1.hardware;
+ struct Channel *chanp = st->lli.userdata;
+ int i;
- 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;
+ if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
+ i=1;
+ else
+ i=0;
+ while (i<2) {
+ if (chanp->fi.state == ST_NULL)
+ return (chanp);
+ chanp++;
+ i++;
}
+ return (NULL);
}
-static void
-cc_l2man(struct PStack *st, int pr, void *arg)
+int
+is_activ(struct PStack *st)
{
- struct Channel *chanp = (struct Channel *) st->l4.userdata;
+ struct IsdnCardState *cs = st->l1.hardware;
+ struct Channel *chanp = st->lli.userdata;
+ int i;
- 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;
+ if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
+ i=1;
+ else
+ i=0;
+ while (i<2) {
+ if (test_bit(FLG_ESTAB_D, &chanp->Flags))
+ return (1);
+ chanp++;
+ i++;
}
+ return (0);
}
static void
-dcc_l1man(struct PStack *st, int pr, void *arg)
+dchan_l3l4(struct PStack *st, int pr, void *arg)
{
- struct Channel *chanp = (struct Channel *) st->l4.userdata;
+ struct l3_process *pc = arg;
+ struct IsdnCardState *cs = st->l1.hardware;
+ struct Channel *chanp;
+ int event;
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);
+ case (DL_ESTABLISH | INDICATION):
+ event = EV_DLEST;
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);
+ case (DL_RELEASE | INDICATION):
+ event = EV_DLRL;
break;
- case (DL_RELEASE):
- FsmEvent(&chanp->lc_b.lcfi, EV_LC_DL_RELEASE, NULL);
+ default:
+ event = -1;
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);
-}
+ if (event >= 0) {
+ int i;
-static void
-ll_handler(struct PStack *st, int pr, void *arg)
-{
- struct Channel *chanp = (struct Channel *) st->l4.userdata;
- char tmp[64], tm[32];
+ chanp = st->lli.userdata;
+ if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
+ i = 1;
+ else
+ i = 0;
+ while (i < 2) {
+ FsmEvent(&chanp->fi, event, NULL);
+ chanp++;
+ i++;
+ }
+ return;
+ } else if (pr == (CC_SETUP | INDICATION)) {
+ if (!(chanp = selectfreechannel(pc->st))) {
+ pc->st->lli.l4l3(pc->st, CC_DLRL | REQUEST, pc);
+ } else {
+ chanp->proc = pc;
+ pc->chan = chanp;
+ FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
+ }
+ return;
+ }
+ if (!(chanp = pc->chan))
+ return;
switch (pr) {
- case (CC_DISCONNECT_IND):
+ case (CC_DISCONNECT | INDICATION):
FsmEvent(&chanp->fi, EV_DISCONNECT_IND, NULL);
break;
- case (CC_RELEASE_CNF):
+ case (CC_RELEASE | CONFIRM):
FsmEvent(&chanp->fi, EV_RELEASE_CNF, NULL);
break;
- case (CC_SETUP_IND):
- FsmEvent(&chanp->fi, EV_SETUP_IND, NULL);
+ case (CC_SUSPEND | CONFIRM):
+ FsmEvent(&chanp->fi, EV_RELEASE_CNF, NULL);
+ break;
+ case (CC_RESUME | CONFIRM):
+ FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
break;
- case (CC_RELEASE_IND):
+ case (CC_RESUME_ERR):
+ FsmEvent(&chanp->fi, EV_RELEASE_CNF, NULL);
+ break;
+ case (CC_RELEASE | INDICATION):
FsmEvent(&chanp->fi, EV_RELEASE_IND, NULL);
break;
- case (CC_SETUP_COMPLETE_IND):
+ case (CC_SETUP_COMPL | INDICATION):
FsmEvent(&chanp->fi, EV_SETUP_CMPL_IND, NULL);
break;
- case (CC_SETUP_CNF):
+ case (CC_SETUP | CONFIRM):
FsmEvent(&chanp->fi, EV_SETUP_CNF, NULL);
break;
- case (CC_INFO_CHARGE):
+ case (CC_CHARGE | INDICATION):
FsmEvent(&chanp->fi, EV_CINF, NULL);
break;
- case (CC_NOSETUP_RSP_ERR):
+ case (CC_NOSETUP_RSP):
FsmEvent(&chanp->fi, EV_NOSETUP_RSP, NULL);
break;
case (CC_SETUP_ERR):
@@ -1386,130 +1307,97 @@
case (CC_RELEASE_ERR):
FsmEvent(&chanp->fi, EV_RELEASE_ERR, NULL);
break;
+ case (CC_PROCEEDING | INDICATION):
+ case (CC_ALERTING | INDICATION):
+ 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);
+ if (chanp->debug & 0x800) {
+ HiSax_putstatus(chanp->cs, "Ch",
+ "%d L3->L4 unknown primitiv %x",
+ chanp->chan, pr);
}
}
}
static void
-init_is(struct Channel *chanp, unsigned int ces)
+init_d_st(struct Channel *chanp)
{
- struct PStack *st = &chanp->is;
- struct IsdnCardState *sp = chanp->sp;
- char tmp[128];
+ struct PStack *st = chanp->d_st;
+ struct IsdnCardState *cs = chanp->cs;
+ char tmp[16];
- setstack_HiSax(st, sp);
+ HiSax_addlist(cs, st);
+ setstack_HiSax(st, cs);
st->l2.sap = 0;
- st->l2.tei = 255;
- st->l2.ces = ces;
- st->l2.extended = !0;
- st->l2.laptype = LAPD;
+ st->l2.tei = -1;
+ st->l2.flag = 0;
+ test_and_set_bit(FLG_MOD128, &st->l2.flag);
+ test_and_set_bit(FLG_LAPD, &st->l2.flag);
+ test_and_set_bit(FLG_ORIG, &st->l2.flag);
+ st->l2.maxlen = MAX_DFRAME_LEN;
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);
+ st->l2.T200 = 1000; /* 1000 milliseconds */
+ st->l2.N200 = 3; /* try 3 times */
+ st->l2.T203 = 10000; /* 10000 milliseconds */
+ if (test_bit(FLG_TWO_DCHAN, &cs->HW_Flags))
+ sprintf(tmp, "DCh%d Q.921 ", chanp->chan);
+ else
+ sprintf(tmp, "DCh Q.921 ");
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);
+ setstack_l3dc(st, chanp);
+ st->lli.userdata = chanp;
+ st->lli.l2writewakeup = NULL;
+ st->l3.l3l4 = dchan_l3l4;
}
static void
-callc_debug(struct FsmInst *fi, char *s)
+callc_debug(struct FsmInst *fi, char *fmt, ...)
{
- char str[80], tm[32];
+ va_list args;
struct Channel *chanp = fi->userdata;
+ char tmp[16];
- jiftime(tm, jiffies);
- sprintf(str, "%s Channel %d callc %s\n", tm, chanp->chan, s);
- HiSax_putstatus(chanp->sp, str);
+ va_start(args, fmt);
+ sprintf(tmp, "Ch%d callc ", chanp->chan);
+ VHiSax_putstatus(chanp->cs, tmp, fmt, args);
+ va_end(args);
}
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);
+dummy_pstack(struct PStack *st, int pr, void *arg) {
+ printk(KERN_WARNING"call to dummy_pstack pr=%04x arg %lx\n", pr, (long)arg);
}
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);
+init_PStack(struct PStack **stp) {
+ *stp = kmalloc(sizeof(struct PStack), GFP_ATOMIC);
+ (*stp)->next = NULL;
+ (*stp)->l1.l1l2 = dummy_pstack;
+ (*stp)->l1.l1hw = dummy_pstack;
+ (*stp)->l1.l1tei = dummy_pstack;
+ (*stp)->l2.l2tei = dummy_pstack;
+ (*stp)->l2.l2l1 = dummy_pstack;
+ (*stp)->l2.l2l3 = dummy_pstack;
+ (*stp)->l3.l3l2 = dummy_pstack;
+ (*stp)->l3.l3l4 = dummy_pstack;
+ (*stp)->lli.l4l3 = dummy_pstack;
+ (*stp)->ma.layer = dummy_pstack;
}
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)
+init_chan(int chan, struct IsdnCardState *csta)
{
struct Channel *chanp = csta->channel + chan;
- chanp->sp = csta;
- chanp->hscx = hscx;
+ chanp->cs = csta;
+ chanp->bcs = csta->bcs + chan;
chanp->chan = chan;
chanp->incoming = 0;
chanp->debug = 0;
chanp->Flags = 0;
chanp->leased = 0;
- chanp->impair = 0;
- init_is(chanp, ces);
-
+ init_PStack(&chanp->b_st);
+ chanp->b_st->l1.delay = DEFAULT_B_DELAY;
chanp->fi.fsm = &callcfsm;
chanp->fi.state = ST_NULL;
chanp->fi.debug = 0;
@@ -1517,58 +1405,46 @@
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;
+ if (!chan || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
+ init_PStack(&chanp->d_st);
+ if (chan)
+ csta->channel->d_st->next = chanp->d_st;
+ chanp->d_st->next = NULL;
+ init_d_st(chanp);
+ } else {
+ chanp->d_st = csta->channel->d_st;
+ }
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++);
+ init_chan(0, csta);
+ init_chan(1, csta);
printk(KERN_INFO "HiSax: 2 channels added\n");
+ if (test_bit(FLG_PTP, &csta->channel->d_st->l2.flag)) {
+ printk(KERN_INFO "LAYER2 WATCHING ESTABLISH\n");
+ test_and_set_bit(FLG_START_D, &csta->channel->Flags);
+ csta->channel->d_st->lli.l4l3(csta->channel->d_st,
+ DL_ESTABLISH | REQUEST, NULL);
+ }
return (2);
}
static void
-release_is(struct Channel *chanp)
+release_d_st(struct Channel *chanp)
{
- struct PStack *st = &chanp->is;
+ struct PStack *st = chanp->d_st;
+ if (!st)
+ return;
releasestack_isdnl2(st);
releasestack_isdnl3(st);
HiSax_rmlist(st->l1.hardware, st);
+ kfree(st);
+ chanp->d_st = NULL;
}
void
@@ -1579,32 +1455,46 @@
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);
+ if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags))
+ release_d_st(csta->channel + i);
+ if (csta->channel[i].b_st) {
+ if (test_and_clear_bit(FLG_START_B, &csta->channel[i].Flags))
+ release_b_st(csta->channel + i);
+ kfree(csta->channel[i].b_st);
+ csta->channel[i].b_st = NULL;
+ } else
+ printk(KERN_WARNING "CallcFreeChan b_st ch%d allready freed\n", i);
+ if (i || test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
+ release_d_st(csta->channel + i);
+ } else
+ csta->channel[i].d_st = NULL;
}
}
static void
lldata_handler(struct PStack *st, int pr, void *arg)
{
- struct Channel *chanp = (struct Channel *) st->l4.userdata;
+ struct Channel *chanp = (struct Channel *) st->lli.userdata;
struct sk_buff *skb = arg;
switch (pr) {
- case (DL_DATA):
+ case (DL_DATA | INDICATION):
if (chanp->data_open)
- chanp->sp->iif.rcvcallb_skb(chanp->sp->myid, chanp->chan, skb);
+ chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
else {
- SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
}
break;
+ case (DL_ESTABLISH | INDICATION):
+ case (DL_ESTABLISH | CONFIRM):
+ FsmEvent(&chanp->fi, EV_BC_EST, NULL);
+ break;
+ case (DL_RELEASE | INDICATION):
+ case (DL_RELEASE | CONFIRM):
+ FsmEvent(&chanp->fi, EV_BC_REL, NULL);
+ break;
default:
- printk(KERN_WARNING "lldata_handler unknown primitive %d\n",
+ printk(KERN_WARNING "lldata_handler unknown primitive %x\n",
pr);
break;
}
@@ -1613,99 +1503,167 @@
static void
lltrans_handler(struct PStack *st, int pr, void *arg)
{
- struct Channel *chanp = (struct Channel *) st->l4.userdata;
+ struct Channel *chanp = (struct Channel *) st->lli.userdata;
struct sk_buff *skb = arg;
switch (pr) {
- case (PH_DATA):
+ case (PH_DATA | INDICATION):
if (chanp->data_open)
- chanp->sp->iif.rcvcallb_skb(chanp->sp->myid, chanp->chan, skb);
+ chanp->cs->iif.rcvcallb_skb(chanp->cs->myid, chanp->chan, skb);
else {
- SET_SKB_FREE(skb);
+ link_debug(chanp, 0, "channel not open");
dev_kfree_skb(skb, FREE_READ);
}
break;
+ case (PH_ACTIVATE | INDICATION):
+ case (PH_ACTIVATE | CONFIRM):
+ FsmEvent(&chanp->fi, EV_BC_EST, NULL);
+ break;
+ case (PH_DEACTIVATE | INDICATION):
+ case (PH_DEACTIVATE | CONFIRM):
+ FsmEvent(&chanp->fi, EV_BC_REL, NULL);
+ break;
default:
- printk(KERN_WARNING "lltrans_handler unknown primitive %d\n",
+ printk(KERN_WARNING "lltrans_handler unknown primitive %x\n",
pr);
break;
}
}
static void
-ll_writewakeup(struct PStack *st)
+ll_writewakeup(struct PStack *st, int len)
{
- struct Channel *chanp = st->l4.userdata;
+ struct Channel *chanp = st->lli.userdata;
isdn_ctrl ic;
- ic.driver = chanp->sp->myid;
+ ic.driver = chanp->cs->myid;
ic.command = ISDN_STAT_BSENT;
ic.arg = chanp->chan;
- chanp->sp->iif.statcallb(&ic);
+// ic.parm.length = len;
+ chanp->cs->iif.statcallb(&ic);
}
static int
-init_ds(struct Channel *chanp, int incoming)
+init_b_st(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))
+ struct PStack *st = chanp->b_st;
+ struct IsdnCardState *cs = chanp->cs;
+ char tmp[16];
+
+ st->l1.hardware = cs;
+ if (chanp->leased)
+ st->l1.bc = chanp->chan & 1;
+ else
+ st->l1.bc = chanp->proc->para.bchannel - 1;
+ switch (chanp->l2_active_protocol) {
+ case (ISDN_PROTO_L2_X75I):
+ case (ISDN_PROTO_L2_HDLC):
+ st->l1.mode = L1_MODE_HDLC;
+ break;
+ case (ISDN_PROTO_L2_TRANS):
+ st->l1.mode = L1_MODE_TRANS;
+ break;
+#if 0
+ case (ISDN_PROTO_L2_MODEM):
+ st->l1.mode = L1_MODE_MODEM;
+ break;
+#endif
+ }
+ if (chanp->bcs->BC_SetStack(st, chanp->bcs))
return (-1);
-
- st->l2.extended = 0;
- st->l2.laptype = LAPB;
- st->l2.orig = !incoming;
- st->l2.t200 = 1000; /* 1000 milliseconds */
+ st->l2.flag = 0;
+ test_and_set_bit(FLG_LAPB, &st->l2.flag);
+ st->l2.maxlen = MAX_DATA_SIZE;
+ if (!incoming)
+ test_and_set_bit(FLG_ORIG, &st->l2.flag);
+ st->l2.T200 = 1000; /* 1000 milliseconds */
st->l2.window = 7;
- st->l2.n200 = 4; /* try 4 times */
- st->l2.t203 = 5000; /* 5000 milliseconds */
-
+ 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);
+ sprintf(tmp, "Ch%d X.75", chanp->chan);
setstack_isdnl2(st, tmp);
+ setstack_l3bc(st, chanp);
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->lli.userdata = chanp;
+ st->lli.l1writewakeup = NULL;
+ st->lli.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):
+// case (ISDN_PROTO_L2_MODEM):
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;
+ st->lli.userdata = chanp;
+ st->lli.l1writewakeup = ll_writewakeup;
+ setstack_transl2(st);
+ setstack_l3bc(st, chanp);
break;
}
return (0);
}
static void
+leased_l4l3(struct PStack *st, int pr, void *arg)
+{
+ struct Channel *chanp = (struct Channel *) st->lli.userdata;
+ struct sk_buff *skb = arg;
+
+ switch (pr) {
+ case (DL_DATA | REQUEST):
+ link_debug(chanp, 0, "leased line d-channel DATA");
+ dev_kfree_skb(skb, FREE_READ);
+ break;
+ case (DL_ESTABLISH | REQUEST):
+ st->l2.l2l1(st, PH_ACTIVATE | REQUEST, NULL);
+ break;
+ case (DL_RELEASE | REQUEST):
+ break;
+ default:
+ printk(KERN_WARNING "transd_l4l3 unknown primitive %x\n",
+ pr);
+ break;
+ }
+}
+
+static void
+leased_l1l2(struct PStack *st, int pr, void *arg)
+{
+ struct Channel *chanp = (struct Channel *) st->lli.userdata;
+ struct sk_buff *skb = arg;
+ int i,event = EV_DLRL;
+
+ switch (pr) {
+ case (PH_DATA | INDICATION):
+ link_debug(chanp, 0, "leased line d-channel DATA");
+ dev_kfree_skb(skb, FREE_READ);
+ break;
+ case (PH_ACTIVATE | INDICATION):
+ case (PH_ACTIVATE | CONFIRM):
+ event = EV_DLEST;
+ case (PH_DEACTIVATE | INDICATION):
+ case (PH_DEACTIVATE | CONFIRM):
+ if (test_bit(FLG_TWO_DCHAN, &chanp->cs->HW_Flags))
+ i = 1;
+ else
+ i = 0;
+ while (i < 2) {
+ FsmEvent(&chanp->fi, event, NULL);
+ chanp++;
+ i++;
+ }
+ break;
+ default:
+ printk(KERN_WARNING
+ "transd_l1l2 unknown primitive %x\n", pr);
+ break;
+ }
+}
+
+static void
channel_report(struct Channel *chanp)
{
}
@@ -1719,25 +1677,86 @@
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;
+ chanp[i].d_st->l2.l2m.debug = debugflags & 8;
+ chanp[i].b_st->l2.l2m.debug = debugflags & 0x10;
+ chanp[i].d_st->l2.debug = debugflags & 0x20;
+ chanp[i].b_st->l2.debug = debugflags & 0x40;
+ chanp[i].d_st->l3.l3m.debug = debugflags & 0x80;
+ chanp[i].b_st->l3.l3m.debug = debugflags & 0x100;
+ chanp[i].b_st->ma.tei_m.debug = debugflags & 0x200;
+ chanp[i].b_st->ma.debug = debugflags & 0x200;
+ chanp[i].d_st->l1.l1m.debug = debugflags & 0x1000;
+ chanp[i].b_st->l1.l1m.debug = debugflags & 0x2000;
}
- csta->dlogflag = debugflags & 4;
- csta->teistack->l2.l2m.debug = debugflags & 512;
+ if (debugflags & 4)
+ csta->debug |= DEB_DLOG_HEX;
+ else
+ csta->debug &= ~DEB_DLOG_HEX;
}
+#if 0
+static char tmpbuf[256];
+
+static void
+capi_debug(struct Channel *chanp, capi_msg *cm)
+{
+ char *t = tmpbuf;
+
+ t += sprintf(tmpbuf, "%d CAPIMSG", chanp->chan);
+ t += QuickHex(t, (u_char *)cm, (cm->Length>50)? 50: cm->Length);
+ t--;
+ *t= 0;
+ HiSax_putstatus(chanp->cs, "Ch", "%d CAPIMSG %s", chanp->chan, tmpbuf);
+}
+
+void
+lli_got_fac_req(struct Channel *chanp, capi_msg *cm) {
+ if ((cm->para[0] != 3) || (cm->para[1] != 0))
+ return;
+ if (cm->para[2]<3)
+ return;
+ if (cm->para[4] != 0)
+ return;
+ switch(cm->para[3]) {
+ case 4: /* Suspend */
+ if (cm->para[5]) {
+ strncpy(chanp->setup.phone, &cm->para[5], cm->para[5] +1);
+ FsmEvent(&chanp->fi, EV_SUSPEND, cm);
+ }
+ break;
+ case 5: /* Resume */
+ if (cm->para[5]) {
+ strncpy(chanp->setup.phone, &cm->para[5], cm->para[5] +1);
+ if (chanp->fi.state == ST_NULL) {
+ FsmEvent(&chanp->fi, EV_RESUME, cm);
+ } else {
+ FsmDelTimer(&chanp->dial_timer, 72);
+ FsmAddTimer(&chanp->dial_timer, 80, EV_RESUME, cm, 73);
+ }
+ }
+ break;
+ }
+}
+
+void
+lli_got_manufacturer(struct Channel *chanp, struct IsdnCardState *cs, capi_msg *cm) {
+ if ((cs->typ == ISDN_CTYPE_ELSA) || (cs->typ == ISDN_CTYPE_ELSA_PNP) ||
+ (cs->typ == ISDN_CTYPE_ELSA_PCI)) {
+ if (cs->hw.elsa.MFlag) {
+ cs->cardmsg(cs, CARD_AUX_IND, cm->para);
+ }
+ }
+}
+#endif
+
int
HiSax_command(isdn_ctrl * ic)
{
struct IsdnCardState *csta = hisax_findcard(ic->driver);
struct Channel *chanp;
- char tmp[128];
int i;
- unsigned int num;
+ u_int num;
+ u_long adr;
if (!csta) {
printk(KERN_ERR
@@ -1745,32 +1764,35 @@
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);
- }
+ if (chanp->debug & 1)
+ link_debug(chanp, 1, "SETL2 card %d %ld",
+ csta->cardnr + 1, ic->arg >> 8);
chanp->l2_protocol = ic->arg >> 8;
break;
+ case (ISDN_CMD_SETL3):
+ chanp = csta->channel + (ic->arg & 0xff);
+ if (chanp->debug & 1)
+ link_debug(chanp, 1, "SETL3 card %d %ld",
+ csta->cardnr + 1, ic->arg >> 8);
+ chanp->l3_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)",
+ if (chanp->debug & 1)
+ link_debug(chanp, 1, "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';
+ ic->parm.setup.si1, ic->parm.setup.si2);
+ chanp->setup = ic->parm.setup;
+ if (!strcmp(chanp->setup.eazmsn, "0"))
+ chanp->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) {
@@ -1783,57 +1805,56 @@
case (ISDN_CMD_ACCEPTB):
chanp = csta->channel + ic->arg;
if (chanp->debug & 1)
- link_debug(chanp, "ACCEPTB", 1);
+ link_debug(chanp, 1, "ACCEPTB");
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);
+ link_debug(chanp, 1, "ACCEPTD");
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);
+ link_debug(chanp, 1, "HANGUP");
FsmEvent(&chanp->fi, EV_HANGUP, NULL);
break;
- case (ISDN_CMD_SUSPEND):
+#if 0
+ case (CAPI_PUT_MESSAGE):
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);
+ if (chanp->debug & 1)
+ capi_debug(chanp, &ic->parm.cmsg);
+ if (ic->parm.cmsg.Length < 8)
+ break;
+ switch(ic->parm.cmsg.Command) {
+ case CAPI_FACILITY:
+ if (ic->parm.cmsg.Subcommand == CAPI_REQ)
+ lli_got_fac_req(chanp, &ic->parm.cmsg);
+ break;
+ case CAPI_MANUFACTURER:
+ if (ic->parm.cmsg.Subcommand == CAPI_REQ)
+ lli_got_manufacturer(chanp, csta, &ic->parm.cmsg);
+ break;
+ default:
+ break;
}
- FsmEvent(&chanp->fi, EV_RESUME, ic);
break;
+#endif
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);
- }
+ if (csta->channel[0].debug & 0x400)
+ HiSax_putstatus(csta, " LOCK ", "modcnt %lx",
+ MOD_USE_COUNT);
#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);
- }
+ if (csta->channel[0].debug & 0x400)
+ HiSax_putstatus(csta, " UNLOCK ", "modcnt %lx",
+ MOD_USE_COUNT);
#endif /* MODULE */
break;
case (ISDN_CMD_IOCTL):
@@ -1846,22 +1867,19 @@
case (1):
num = *(unsigned int *) ic->parm.num;
distr_debug(csta, num);
- sprintf(tmp, "debugging flags card %d set to %x\n",
+ printk(KERN_DEBUG "HiSax: debugging flags card %d set to %x\n",
csta->cardnr + 1, num);
- HiSax_putstatus(csta, tmp);
- printk(KERN_DEBUG "HiSax: %s", tmp);
+ HiSax_putstatus(csta, "debugging flags ",
+ "card %d set to %x", csta->cardnr + 1, num);
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);
- }
+ csta->channel[0].b_st->l1.delay = num;
+ csta->channel[1].b_st->l1.delay = num;
+ HiSax_putstatus(csta, "delay ", "card %d set to %d ms",
+ csta->cardnr + 1, num);
+ printk(KERN_DEBUG "HiSax: delay card %d set to %d ms\n",
+ csta->cardnr + 1, num);
break;
case (3):
for (i = 0; i < *(unsigned int *) ic->parm.num; i++)
@@ -1872,36 +1890,92 @@
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);
+ num = *(unsigned int *) ic->parm.num;
+ if ((num <1) || (num > 2)) {
+ HiSax_putstatus(csta, "Set LEASED ",
+ "wrong channel %d", num);
+ printk(KERN_WARNING "HiSax: Set LEASED wrong channel %d\n",
+ num);
+ } else {
+ num--;
+ chanp = csta->channel +num;
+ chanp->leased = 1;
+ HiSax_putstatus(csta, "Card",
+ "%d channel %d set leased mode\n",
+ csta->cardnr + 1, num + 1);
+ chanp->d_st->l1.l1l2 = leased_l1l2;
+ chanp->d_st->lli.l4l3 = leased_l4l3;
+ chanp->d_st->lli.l4l3(chanp->d_st,
+ DL_ESTABLISH | REQUEST, NULL);
+ }
+ break;
+ case (6): /* set B-channel test loop */
+ num = *(unsigned int *) ic->parm.num;
+ if (csta->stlist)
+ csta->stlist->l2.l2l1(csta->stlist,
+ PH_TESTLOOP | REQUEST, (void *) (long)num);
+ break;
+ case (7): /* set card in PTP mode */
+ num = *(unsigned int *) ic->parm.num;
+ if (test_bit(FLG_TWO_DCHAN, &csta->HW_Flags)) {
+ printk(KERN_ERR "HiSax PTP mode only with one TEI possible\n");
+ } else if (num) {
+ test_and_set_bit(FLG_PTP, &csta->channel[0].d_st->l2.flag);
+ test_and_set_bit(FLG_FIXED_TEI, &csta->channel[0].d_st->l2.flag);
+ csta->channel[0].d_st->l2.tei = 0;
+ HiSax_putstatus(csta, "set card ", "in PTP mode");
+ printk(KERN_DEBUG "HiSax: set card in PTP mode\n");
+ printk(KERN_INFO "LAYER2 WATCHING ESTABLISH\n");
+ test_and_set_bit(FLG_START_D, &csta->channel[0].Flags);
+ test_and_set_bit(FLG_START_D, &csta->channel[1].Flags);
+ csta->channel[0].d_st->lli.l4l3(csta->channel[0].d_st,
+ DL_ESTABLISH | REQUEST, NULL);
+ } else {
+ test_and_clear_bit(FLG_PTP, &csta->channel[0].d_st->l2.flag);
+ test_and_clear_bit(FLG_FIXED_TEI, &csta->channel[0].d_st->l2.flag);
+ HiSax_putstatus(csta, "set card ", "in PTMP mode");
+ printk(KERN_DEBUG "HiSax: set card in PTMP mode\n");
+ }
+ break;
+ case (8): /* set card in FIXED TEI mode */
+ num = *(unsigned int *) ic->parm.num;
+ chanp = csta->channel + (num & 1);
+ num = num >>1;
+ test_and_set_bit(FLG_FIXED_TEI, &chanp->d_st->l2.flag);
+ chanp->d_st->l2.tei = num;
+ HiSax_putstatus(csta, "set card ", "in FIXED TEI (%d) mode", num);
+ printk(KERN_DEBUG "HiSax: set card in FIXED TEI (%d) mode\n",
+ num);
+ break;
+ case (9): /* load firmware */
+ memcpy(&adr, ic->parm.num, sizeof(ulong));
+ csta->cardmsg(csta, CARD_LOAD_FIRM,
+ (void *) adr);
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):
+ num = csta->debug & DEB_DLOG_HEX;
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);
+ csta->debug |= num;
+ HiSax_putstatus(cards[0].cs, "l1 debugging ",
+ "flags card %d set to %x",
+ csta->cardnr + 1, csta->debug);
+ printk(KERN_DEBUG "HiSax: l1 debugging flags card %d set to %x\n",
+ csta->cardnr + 1, csta->debug);
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->channel[0].d_st->l3.debug = *(unsigned int *) ic->parm.num;
+ csta->channel[1].d_st->l3.debug = *(unsigned int *) ic->parm.num;
+ HiSax_putstatus(cards[0].cs, "l3 debugging ",
+ "flags card %d set to %x\n", csta->cardnr + 1,
+ *(unsigned int *) ic->parm.num);
+ printk(KERN_DEBUG "HiSax: 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",
@@ -1925,7 +1999,6 @@
int len = skb->len;
unsigned long flags;
struct sk_buff *nskb;
- char tmp[64];
if (!csta) {
printk(KERN_ERR
@@ -1933,38 +2006,37 @@
return -ENODEV;
}
chanp = csta->channel + chan;
- st = &chanp->ds;
+ st = chanp->b_st;
if (!chanp->data_open) {
- link_debug(chanp, "writebuf: channel not open", 1);
+ link_debug(chanp, 1, "writebuf: channel not open");
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);
+ link_debug(chanp, 1, "writebuf: packet too large (%d bytes)", len);
+ printk(KERN_WARNING "HiSax_writebuf: packet too large (%d bytes) !\n",
+ len);
return -EINVAL;
}
if (len) {
- if ((len + csta->hs[chanp->hscx].tx_cnt) > MAX_DATA_MEM) {
+ if ((len + chanp->bcs->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);
- }
+ if (chanp->debug & 0x800)
+ link_debug(chanp, 1, "writebuf: no buffers for %d bytes", len);
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);
+// if (!ack)
+// nskb->pkt_type = PACKET_NOACK;
+ if (chanp->l2_active_protocol == ISDN_PROTO_L2_X75I)
+ st->l3.l3l2(st, DL_DATA | REQUEST, nskb);
+ else {
+ chanp->bcs->tx_cnt += len;
+ st->l2.l2l1(st, PH_DATA | REQUEST, nskb);
}
dev_kfree_skb(skb, FREE_WRITE);
} else
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen, slshen@lbl.gov