1588 lines
36 KiB
C
1588 lines
36 KiB
C
/* $Id$
|
|
*
|
|
* interface for old I4L hardware drivers to the CAPI driver
|
|
*
|
|
* Copyright (C) 2003 Karsten Keil (kkeil@suse.de)
|
|
*
|
|
* Author Karsten Keil (kkeil@suse.de)
|
|
*
|
|
* This file is (c) under GNU PUBLIC LICENSE
|
|
*
|
|
*/
|
|
|
|
#include <linux/config.h>
|
|
#include <linux/module.h>
|
|
#include <linux/isdnif.h>
|
|
#include <linux/delay.h>
|
|
#include <asm/semaphore.h>
|
|
#include <linux/mISDNif.h>
|
|
#include "fsm.h"
|
|
#include "helper.h"
|
|
#include "dss1.h"
|
|
#include "debug.h"
|
|
|
|
static char *i4lcapi_revision = "$Revision$";
|
|
|
|
/* data struct */
|
|
typedef struct _i4l_channel i4l_channel_t;
|
|
typedef struct _i4l_capi i4l_capi_t;
|
|
|
|
struct _i4l_channel {
|
|
mISDNinstance_t inst;
|
|
i4l_capi_t *drv;
|
|
int nr;
|
|
u_int Flags;
|
|
int cause_loc;
|
|
int cause_val;
|
|
u_int l4id;
|
|
struct FsmInst i4lm;
|
|
struct sk_buff_head sendq;
|
|
struct sk_buff_head ackq;
|
|
};
|
|
|
|
struct _i4l_capi {
|
|
i4l_capi_t *prev;
|
|
i4l_capi_t *next;
|
|
isdn_if *interface;
|
|
mISDNinstance_t inst;
|
|
mISDN_pid_t pid;
|
|
int idx;
|
|
int locks;
|
|
int debug;
|
|
int nr_ch;
|
|
i4l_channel_t *ch;
|
|
};
|
|
|
|
#define I4L_FLG_LOCK 0
|
|
#define I4L_FLG_L1TRANS 1
|
|
#define I4L_FLG_L1HDLC 2
|
|
#define I4L_FLG_LAYER1 3
|
|
#define I4L_FLG_BREADY 4
|
|
#define I4L_FLG_BCONN 5
|
|
#define I4L_FLG_HANGUP 6
|
|
|
|
static
|
|
struct Fsm i4lfsm_s =
|
|
{NULL, 0, 0, NULL, NULL};
|
|
|
|
enum {
|
|
ST_NULL,
|
|
ST_ICALL,
|
|
ST_OCALL,
|
|
ST_PROCEED,
|
|
ST_ALERT,
|
|
ST_WAITDCONN,
|
|
ST_ACTIVD,
|
|
ST_BREADY,
|
|
ST_ACTIVB,
|
|
ST_HANGUP,
|
|
};
|
|
|
|
#define STATE_COUNT (ST_HANGUP+1)
|
|
|
|
static char *strI4LState[] =
|
|
{
|
|
"ST_NULL",
|
|
"ST_ICALL",
|
|
"ST_OCALL",
|
|
"ST_PROCEED",
|
|
"ST_ALERT",
|
|
"ST_WAITDCONN",
|
|
"ST_ACTIVD",
|
|
"ST_BREADY",
|
|
"ST_ACTIVB",
|
|
"ST_HANGUP",
|
|
};
|
|
|
|
enum {
|
|
EV_I4L_ICALL,
|
|
EV_I4L_DCONN,
|
|
EV_I4L_BCONN,
|
|
EV_I4L_DHUP,
|
|
EV_I4L_BHUP,
|
|
EV_I4L_L1ERR,
|
|
EV_STACKREADY,
|
|
EV_CAPI_OCALL,
|
|
EV_CAPI_ALERT,
|
|
EV_CAPI_PROCEED,
|
|
EV_CAPI_DCONNECT,
|
|
EV_CAPI_ESTABLISHB,
|
|
EV_CAPI_RELEASEB,
|
|
EV_CAPI_DISCONNECT,
|
|
EV_CAPI_RELEASE,
|
|
};
|
|
|
|
#define EVENT_COUNT (EV_CAPI_RELEASE + 1)
|
|
|
|
static char *strI4LEvent[] =
|
|
{
|
|
"EV_I4L_ICALL",
|
|
"EV_I4L_DCONN",
|
|
"EV_I4L_BCONN",
|
|
"EV_I4L_DHUP",
|
|
"EV_I4L_BHUP",
|
|
"EV_I4L_L1ERR",
|
|
"EV_STACKREADY",
|
|
"EV_CAPI_OCALL",
|
|
"EV_CAPI_ALERT",
|
|
"EV_CAPI_PROCEED",
|
|
"EV_CAPI_DCONNECT",
|
|
"EV_CAPI_ESTABLISHB",
|
|
"EV_CAPI_RELEASEB",
|
|
"EV_CAPI_DISCONNECT",
|
|
"EV_CAPI_RELEASE",
|
|
};
|
|
|
|
static void
|
|
i4lm_debug(struct FsmInst *fi, char *fmt, ...)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
logdata_t log;
|
|
|
|
va_start(log.args, fmt);
|
|
log.fmt = fmt;
|
|
log.head = ch->inst.name;
|
|
ch->inst.obj->ctrl(&ch->inst, MGR_DEBUGDATA | REQUEST, &log);
|
|
va_end(log.args);
|
|
}
|
|
|
|
#define MAX_CARDS 8
|
|
static i4l_capi_t *drvmap[MAX_CARDS];
|
|
static mISDNobject_t I4Lcapi;
|
|
|
|
static int debug;
|
|
|
|
#ifdef MODULE
|
|
MODULE_AUTHOR("Karsten Keil");
|
|
#ifdef MODULE_LICENSE
|
|
MODULE_LICENSE("GPL");
|
|
#endif
|
|
MODULE_PARM(debug, "1i");
|
|
#endif
|
|
|
|
static void
|
|
i4l_lock_drv(i4l_capi_t *ic)
|
|
{
|
|
isdn_ctrl cmd;
|
|
|
|
cmd.driver = ic->idx;
|
|
cmd.arg = 0;
|
|
cmd.command = ISDN_CMD_LOCK;
|
|
ic->interface->command(&cmd);
|
|
ic->locks++;
|
|
}
|
|
|
|
static void
|
|
i4l_unlock_drv(i4l_capi_t *ic)
|
|
{
|
|
isdn_ctrl cmd;
|
|
|
|
cmd.driver = ic->idx;
|
|
cmd.arg = 0;
|
|
cmd.command = ISDN_CMD_UNLOCK;
|
|
ic->interface->command(&cmd);
|
|
ic->locks--;
|
|
}
|
|
|
|
static int
|
|
i4l_cmd(i4l_capi_t *ic, int arg, int cmd)
|
|
{
|
|
isdn_ctrl ctrl;
|
|
|
|
ctrl.driver = ic->idx;
|
|
ctrl.arg = arg;
|
|
ctrl.command = cmd;
|
|
return(ic->interface->command(&ctrl));
|
|
}
|
|
|
|
static void
|
|
init_channel(i4l_capi_t *ic, int nr)
|
|
{
|
|
i4l_channel_t *ch;
|
|
|
|
ch = ic->ch + nr;
|
|
memset(ch, 0, sizeof(i4l_channel_t));
|
|
ch->nr = nr;
|
|
ch->drv = ic;
|
|
ch->i4lm.debug = debug & 0x8;
|
|
ch->i4lm.userdata = ch;
|
|
ch->i4lm.userint = 0;
|
|
ch->i4lm.printdebug = i4lm_debug;
|
|
ch->i4lm.fsm = &i4lfsm_s;
|
|
ch->i4lm.state = ST_NULL;
|
|
skb_queue_head_init(&ch->sendq);
|
|
skb_queue_head_init(&ch->ackq);
|
|
ch->inst.obj = &I4Lcapi;
|
|
ch->inst.data = ch;
|
|
ch->inst.pid.layermask = ISDN_LAYER(0);
|
|
ch->inst.up.owner = &ch->inst;
|
|
ch->inst.down.owner = &ch->inst;
|
|
I4Lcapi.ctrl(NULL, MGR_DISCONNECT | REQUEST, &ch->inst.down);
|
|
sprintf(ch->inst.name, "%s B%d", ic->inst.name, nr+1);
|
|
}
|
|
|
|
static void
|
|
reset_channel(i4l_channel_t *ch)
|
|
{
|
|
ch->cause_loc = 0;
|
|
ch->cause_val = 0;
|
|
ch->l4id = 0;
|
|
skb_queue_purge(&ch->sendq);
|
|
skb_queue_purge(&ch->ackq);
|
|
if (test_and_clear_bit(I4L_FLG_LOCK, &ch->Flags))
|
|
i4l_unlock_drv(ch->drv);
|
|
ch->Flags = 0;
|
|
}
|
|
|
|
static void
|
|
release_card(int idx) {
|
|
i4l_capi_t *ic = drvmap[idx];
|
|
i4l_channel_t *ch;
|
|
int i;
|
|
mISDNinstance_t *inst;
|
|
|
|
if (!ic)
|
|
return;
|
|
drvmap[idx] = NULL;
|
|
ch = ic->ch;
|
|
for (i=0; i<ic->nr_ch; i++) {
|
|
inst = &ch->inst;
|
|
if (inst->up.peer)
|
|
inst->up.peer->obj->ctrl(inst->up.peer,
|
|
MGR_DISCONNECT | REQUEST, &inst->up);
|
|
reset_channel(ch);
|
|
ch++;
|
|
}
|
|
inst = &ic->inst;
|
|
if (inst->up.peer) {
|
|
inst->up.peer->obj->ctrl(inst->up.peer,
|
|
MGR_DISCONNECT | REQUEST, &inst->up);
|
|
}
|
|
REMOVE_FROM_LISTBASE(ic, ((i4l_capi_t *)I4Lcapi.ilist));
|
|
while (ic->locks > 0)
|
|
i4l_unlock_drv(ic);
|
|
kfree(ic->ch);
|
|
ic->ch = NULL;
|
|
kfree(ic);
|
|
I4Lcapi.refcnt--;
|
|
}
|
|
|
|
static int
|
|
sendup(i4l_channel_t *ch, int Dchannel, int prim, struct sk_buff *skb)
|
|
{
|
|
int ret;
|
|
mISDN_headext_t *hhe;
|
|
mISDNinstance_t *I;
|
|
|
|
if (!skb) {
|
|
skb = alloc_skb(8, GFP_ATOMIC);
|
|
if (!skb)
|
|
return(-ENOMEM);
|
|
}
|
|
hhe = mISDN_HEADEXT_P(skb);
|
|
hhe->prim = prim;
|
|
hhe->dinfo = ch->l4id;
|
|
if (ch->drv->debug & 0x4)
|
|
mISDN_LogL3Msg(skb);
|
|
if (Dchannel)
|
|
I = &ch->drv->inst;
|
|
else
|
|
I = &ch->inst;
|
|
if (!I->up.func) {
|
|
int_error();
|
|
dev_kfree_skb(skb);
|
|
return(-EUNATCH);
|
|
}
|
|
if (in_interrupt()) {
|
|
hhe->func.iff = I->up.func;
|
|
hhe->data[0] = &I->up;
|
|
ret = I->obj->ctrl(NULL, MGR_QUEUEIF | REQUEST, skb);
|
|
} else
|
|
ret = I->up.func(&I->up, skb);
|
|
if (ret)
|
|
dev_kfree_skb(skb);
|
|
return(ret);
|
|
}
|
|
|
|
static int
|
|
sendqueued(i4l_channel_t *ch)
|
|
{
|
|
struct sk_buff *skb, *s_skb;
|
|
int len, ret;
|
|
|
|
if (!test_bit(I4L_FLG_BCONN, &ch->Flags)) {
|
|
if (ch->drv->debug & 0x40)
|
|
printk(KERN_DEBUG "%s: bc%d not ready\n", __FUNCTION__, ch->nr);
|
|
return(0);
|
|
}
|
|
while ((skb = skb_dequeue(&ch->sendq))) {
|
|
s_skb = skb_clone(skb, GFP_ATOMIC);
|
|
len = s_skb->len;
|
|
skb_queue_tail(&ch->ackq, skb);
|
|
ret = ch->drv->interface->writebuf_skb(ch->drv->idx, ch->nr, 1, s_skb);
|
|
if (ch->drv->debug & 0x800)
|
|
printk(KERN_DEBUG "bc%d sent skb(%p) %d(%d)\n", ch->nr, skb, ret, len);
|
|
if (ret == len) {
|
|
continue;
|
|
} else if (ret > 0) {
|
|
skb_queue_head(&ch->sendq, s_skb);
|
|
break;
|
|
} else {
|
|
skb_unlink(skb);
|
|
skb_queue_head(&ch->sendq, skb);
|
|
if (!ret)
|
|
dev_kfree_skb(s_skb);
|
|
break;
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
static u_char *
|
|
EncodeASyncParams(u_char * p, u_char si2)
|
|
{ // 7c 06 88 90 21 42 00 bb
|
|
p[0] = 0;
|
|
p[1] = 0x40; // Intermediate rate: 16 kbit/s jj 2000.02.19
|
|
p[2] = 0x80;
|
|
if (si2 & 32) // 7 data bits
|
|
p[2] += 16;
|
|
else // 8 data bits
|
|
p[2] += 24;
|
|
|
|
if (si2 & 16) // 2 stop bits
|
|
p[2] += 96;
|
|
else // 1 stop bit
|
|
p[2] += 32;
|
|
if (si2 & 8) // even parity
|
|
p[2] += 2;
|
|
else // no parity
|
|
p[2] += 3;
|
|
switch (si2 & 0x07) {
|
|
case 0:
|
|
p[0] = 66; // 1200 bit/s
|
|
break;
|
|
case 1:
|
|
p[0] = 88; // 1200/75 bit/s
|
|
break;
|
|
case 2:
|
|
p[0] = 87; // 75/1200 bit/s
|
|
break;
|
|
case 3:
|
|
p[0] = 67; // 2400 bit/s
|
|
break;
|
|
case 4:
|
|
p[0] = 69; // 4800 bit/s
|
|
break;
|
|
case 5:
|
|
p[0] = 72; // 9600 bit/s
|
|
break;
|
|
case 6:
|
|
p[0] = 73; // 14400 bit/s
|
|
break;
|
|
case 7:
|
|
p[0] = 75; // 19200 bit/s
|
|
break;
|
|
}
|
|
return p + 3;
|
|
}
|
|
|
|
static u_char
|
|
EncodeSyncParams(u_char si2, u_char ai)
|
|
{
|
|
switch (si2) {
|
|
case 0:
|
|
return ai + 2; // 1200 bit/s
|
|
case 1:
|
|
return ai + 24; // 1200/75 bit/s
|
|
case 2:
|
|
return ai + 23; // 75/1200 bit/s
|
|
case 3:
|
|
return ai + 3; // 2400 bit/s
|
|
case 4:
|
|
return ai + 5; // 4800 bit/s
|
|
case 5:
|
|
return ai + 8; // 9600 bit/s
|
|
case 6:
|
|
return ai + 9; // 14400 bit/s
|
|
case 7:
|
|
return ai + 11; // 19200 bit/s
|
|
case 8:
|
|
return ai + 14; // 48000 bit/s
|
|
case 9:
|
|
return ai + 15; // 56000 bit/s
|
|
case 15:
|
|
return ai + 40; // negotiate bit/s
|
|
default:
|
|
break;
|
|
}
|
|
return ai;
|
|
}
|
|
|
|
static u_char
|
|
DecodeASyncParams(u_char si2, u_char * p)
|
|
{
|
|
u_char info;
|
|
|
|
switch (p[5]) {
|
|
case 66: // 1200 bit/s
|
|
break; // si2 don't change
|
|
case 88: // 1200/75 bit/s
|
|
si2 += 1;
|
|
break;
|
|
case 87: // 75/1200 bit/s
|
|
si2 += 2;
|
|
break;
|
|
case 67: // 2400 bit/s
|
|
si2 += 3;
|
|
break;
|
|
case 69: // 4800 bit/s
|
|
si2 += 4;
|
|
break;
|
|
case 72: // 9600 bit/s
|
|
si2 += 5;
|
|
break;
|
|
case 73: // 14400 bit/s
|
|
si2 += 6;
|
|
break;
|
|
case 75: // 19200 bit/s
|
|
si2 += 7;
|
|
break;
|
|
}
|
|
info = p[7] & 0x7f;
|
|
if ((info & 16) && (!(info & 8))) // 7 data bits
|
|
si2 += 32; // else 8 data bits
|
|
if ((info & 96) == 96) // 2 stop bits
|
|
si2 += 16; // else 1 stop bit
|
|
if ((info & 2) && (!(info & 1))) // even parity
|
|
si2 += 8; // else no parity
|
|
return si2;
|
|
}
|
|
|
|
|
|
static u_char
|
|
DecodeSyncParams(u_char si2, u_char info)
|
|
{
|
|
switch (info & 0x7f) {
|
|
case 40: // bit/s negotiation failed ai := 165 not 175!
|
|
return si2 + 15;
|
|
case 15: // 56000 bit/s failed, ai := 0 not 169 !
|
|
return si2 + 9;
|
|
case 14: // 48000 bit/s
|
|
return si2 + 8;
|
|
case 11: // 19200 bit/s
|
|
return si2 + 7;
|
|
case 9: // 14400 bit/s
|
|
return si2 + 6;
|
|
case 8: // 9600 bit/s
|
|
return si2 + 5;
|
|
case 5: // 4800 bit/s
|
|
return si2 + 4;
|
|
case 3: // 2400 bit/s
|
|
return si2 + 3;
|
|
case 23: // 75/1200 bit/s
|
|
return si2 + 2;
|
|
case 24: // 1200/75 bit/s
|
|
return si2 + 1;
|
|
default: // 1200 bit/s
|
|
return si2;
|
|
}
|
|
}
|
|
|
|
static u_char
|
|
DecodeSI2(u_char *p)
|
|
{
|
|
|
|
if (p) {
|
|
switch (p[4] & 0x0f) {
|
|
case 0x01:
|
|
if (p[1] == 0x04) // sync. Bitratenadaption
|
|
return DecodeSyncParams(160, p[5]); // V.110/X.30
|
|
else if (p[1] == 0x06) // async. Bitratenadaption
|
|
return DecodeASyncParams(192, p); // V.110/X.30
|
|
break;
|
|
case 0x08: // if (p[5] == 0x02) // sync. Bitratenadaption
|
|
if (p[1] > 3)
|
|
return DecodeSyncParams(176, p[5]); // V.120
|
|
break;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void
|
|
i4l_l1err(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
|
|
sendup(ch, 1, DL_RELEASE | INDICATION, NULL);
|
|
reset_channel(ch);
|
|
mISDN_FsmChangeState(fi, ST_NULL);
|
|
}
|
|
|
|
static void
|
|
i4l_dhup(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
struct sk_buff *skb;
|
|
u_char tmp[8];
|
|
|
|
skb = mISDN_alloc_l3msg(8, MT_RELEASE);
|
|
if (!skb)
|
|
return;
|
|
|
|
tmp[0] = IE_CAUSE;
|
|
tmp[1] = 2;
|
|
if (ch->cause_val) {
|
|
tmp[2] = ch->cause_loc;
|
|
tmp[3] = ch->cause_val;
|
|
} else {
|
|
tmp[2] = 0x80;
|
|
tmp[3] = 0x9f; /* normal, unspecified */
|
|
}
|
|
mISDN_AddvarIE(skb, tmp);
|
|
sendup(ch, 1, CC_RELEASE | INDICATION, skb);
|
|
reset_channel(ch);
|
|
mISDN_FsmChangeState(fi, ST_NULL);
|
|
}
|
|
|
|
static void
|
|
i4l_icall(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
setup_parm *setup = arg;
|
|
u_char tmp[36], *p;
|
|
struct sk_buff *skb;
|
|
int i,j;
|
|
|
|
test_and_set_bit(I4L_FLG_LOCK, &ch->Flags);
|
|
i4l_lock_drv(ch->drv);
|
|
if ((skb = alloc_skb(sizeof(int *) + 8, GFP_ATOMIC))) {
|
|
int **idp = (int **)skb_put(skb, sizeof(idp));
|
|
mISDN_head_t *hh = mISDN_HEAD_P(skb);
|
|
|
|
*idp = &ch->l4id;
|
|
hh->prim = CC_NEW_CR | INDICATION;
|
|
i = ch->drv->inst.up.func(&ch->drv->inst.up, skb);
|
|
if (i) {
|
|
int_error();
|
|
dev_kfree_skb(skb);
|
|
return;
|
|
}
|
|
if (ch->drv->debug & 0x2)
|
|
printk(KERN_DEBUG "%s: l4id(%x) ch(%p)->nr %d\n", __FUNCTION__, ch->l4id, ch, ch->nr);
|
|
} else
|
|
return;
|
|
skb = mISDN_alloc_l3msg(260, MT_SETUP);
|
|
if (!skb)
|
|
return;
|
|
p = tmp;
|
|
switch (setup->si1) {
|
|
case 1: /* Telephony */
|
|
*p++ = IE_BEARER;
|
|
*p++ = 0x3; /* Length */
|
|
*p++ = 0x90; /* Coding Std. CCITT, 3.1 kHz audio */
|
|
*p++ = 0x90; /* Circuit-Mode 64kbps */
|
|
*p++ = 0xa3; /* A-Law Audio */
|
|
break;
|
|
case 5: /* Datatransmission 64k, BTX */
|
|
case 7: /* Datatransmission 64k */
|
|
default:
|
|
*p++ = IE_BEARER;
|
|
*p++ = 0x2; /* Length */
|
|
*p++ = 0x88; /* Coding CCITT, unrestr. dig. Info.*/
|
|
*p++ = 0x90; /* Circuit-Mode 64kbps */
|
|
break;
|
|
}
|
|
mISDN_AddvarIE(skb, tmp);
|
|
tmp[0] = IE_CHANNEL_ID;
|
|
tmp[1] = 1;
|
|
tmp[2] = 0x85 + ch->nr;
|
|
mISDN_AddvarIE(skb, tmp);
|
|
if (setup->phone[0]) {
|
|
i = 1;
|
|
if (setup->plan) {
|
|
tmp[i++] = setup->plan;
|
|
if (!(setup->plan & 0x80))
|
|
tmp[i++] = setup->screen;
|
|
} else
|
|
tmp[i++] = 0x81;
|
|
j = 0;
|
|
while (setup->phone[j]) {
|
|
if (setup->phone[j] == '.') /* subaddress */
|
|
break;
|
|
tmp[i++] = setup->phone[j++];
|
|
}
|
|
tmp[0] = i-1;
|
|
mISDN_AddIE(skb, IE_CALLING_PN, tmp);
|
|
if (setup->phone[j] == '.') {
|
|
i = 1;
|
|
tmp[i++] = 0x80;
|
|
j++;
|
|
while (setup->phone[j])
|
|
tmp[i++] = setup->phone[j++];
|
|
tmp[0] = i-1;
|
|
mISDN_AddIE(skb, IE_CALLING_SUB, tmp);
|
|
}
|
|
}
|
|
if (setup->eazmsn[0]) {
|
|
i = 1;
|
|
tmp[i++] = 0x81;
|
|
j = 0;
|
|
while (setup->eazmsn[j]) {
|
|
if (setup->eazmsn[j] == '.') /* subaddress */
|
|
break;
|
|
tmp[i++] = setup->eazmsn[j++];
|
|
}
|
|
tmp[0] = i-1;
|
|
mISDN_AddIE(skb, IE_CALLED_PN, tmp);
|
|
if (setup->eazmsn[j] == '.') {
|
|
i = 1;
|
|
tmp[i++] = 0x80;
|
|
j++;
|
|
while (setup->eazmsn[j])
|
|
tmp[i++] = setup->eazmsn[j++];
|
|
tmp[0] = i-1;
|
|
mISDN_AddIE(skb, IE_CALLED_SUB, tmp);
|
|
}
|
|
}
|
|
p = tmp;
|
|
*p++ = IE_LLC;
|
|
if ((setup->si2 >= 160) && (setup->si2 <= 175)) { // sync. Bitratenadaption, V.110/X.30
|
|
*p++ = 0x04;
|
|
*p++ = 0x88;
|
|
*p++ = 0x90;
|
|
*p++ = 0x21;
|
|
*p++ = EncodeSyncParams(setup->si2 - 160, 0x80);
|
|
test_and_set_bit(I4L_FLG_L1TRANS, &ch->Flags);
|
|
} else if ((setup->si2 >= 176) && (setup->si2 <= 191)) { // sync. Bitratenadaption, V.120
|
|
*p++ = 0x05;
|
|
*p++ = 0x88;
|
|
*p++ = 0x90;
|
|
*p++ = 0x28;
|
|
*p++ = EncodeSyncParams(setup->si2 - 176, 0);
|
|
*p++ = 0x82;
|
|
test_and_set_bit(I4L_FLG_L1TRANS, &ch->Flags);
|
|
} else if (setup->si2 >= 192) { // async. Bitratenadaption, V.110/X.30
|
|
*p++ = 0x06;
|
|
*p++ = 0x88;
|
|
*p++ = 0x90;
|
|
*p++ = 0x21;
|
|
p = EncodeASyncParams(p, setup->si2 - 192);
|
|
test_and_set_bit(I4L_FLG_L1TRANS, &ch->Flags);
|
|
} else {
|
|
switch(setup->si1) {
|
|
case 1:
|
|
*p++ = 0x3;
|
|
*p++ = 0x90;
|
|
*p++ = 0x90;
|
|
*p++ = 0xa3;
|
|
test_and_set_bit(I4L_FLG_L1TRANS, &ch->Flags);
|
|
break;
|
|
case 5:
|
|
case 7:
|
|
default:
|
|
*p++ = 0x2;
|
|
*p++ = 0x88;
|
|
*p++ = 0x90;
|
|
test_and_set_bit(I4L_FLG_L1HDLC, &ch->Flags);
|
|
break;
|
|
}
|
|
}
|
|
mISDN_AddvarIE(skb, tmp);
|
|
mISDN_FsmChangeState(fi, ST_ICALL);
|
|
sendup(ch, 1, CC_SETUP | INDICATION, skb);
|
|
}
|
|
|
|
static void
|
|
i4l_dconn_out(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
struct sk_buff *skb;
|
|
u_char tmp[4];
|
|
|
|
skb = mISDN_alloc_l3msg(4, MT_CONNECT);
|
|
if (!skb)
|
|
return;
|
|
|
|
tmp[0] = IE_CHANNEL_ID;
|
|
tmp[1] = 1;
|
|
tmp[2] = 0x85 + ch->nr;
|
|
mISDN_AddvarIE(skb, tmp);
|
|
sendup(ch, 1, CC_CONNECT | INDICATION, skb);
|
|
mISDN_FsmChangeState(fi, ST_ACTIVD);
|
|
}
|
|
|
|
static void
|
|
i4l_dconn_in(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
|
|
sendup(ch, 1, CC_CONNECT_ACKNOWLEDGE | INDICATION, NULL);
|
|
mISDN_FsmChangeState(fi, ST_ACTIVD);
|
|
}
|
|
|
|
static void
|
|
i4l_bconn_notready(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
|
|
test_and_set_bit(I4L_FLG_BCONN, &ch->Flags);
|
|
}
|
|
|
|
static void
|
|
i4l_bconn(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
int prim = test_bit(I4L_FLG_LAYER1, &ch->Flags) ? PH_ACTIVATE : DL_ESTABLISH;
|
|
|
|
sendup(ch, 0, prim | INDICATION, NULL);
|
|
test_and_set_bit(I4L_FLG_BCONN, &ch->Flags);
|
|
mISDN_FsmChangeState(fi, ST_ACTIVB);
|
|
if (skb_queue_len(&ch->sendq))
|
|
sendqueued(ch);
|
|
}
|
|
|
|
static void
|
|
i4l_bhup(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
int prim = test_bit(I4L_FLG_LAYER1, &ch->Flags) ? PH_DEACTIVATE : DL_RELEASE;
|
|
|
|
mISDN_FsmChangeState(fi, ST_ACTIVD);
|
|
sendup(ch, 0, prim | INDICATION, NULL);
|
|
}
|
|
|
|
static void
|
|
stackready(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
|
|
mISDN_FsmChangeState(fi, ST_BREADY);
|
|
test_and_set_bit(I4L_FLG_BREADY, &ch->Flags);
|
|
if (test_bit(I4L_FLG_BCONN, &ch->Flags))
|
|
mISDN_FsmEvent(&ch->i4lm, EV_I4L_BCONN, NULL);
|
|
}
|
|
|
|
static void
|
|
capi_ocall(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
struct sk_buff *skb = arg;
|
|
Q931_info_t *qi = (Q931_info_t *)skb->data;
|
|
u_char *p, *ps = skb->data;
|
|
isdn_ctrl ctrl;
|
|
int i,l;
|
|
|
|
mISDN_FsmChangeState(fi, ST_OCALL);
|
|
test_and_set_bit(I4L_FLG_LOCK, &ch->Flags);
|
|
i4l_lock_drv(ch->drv);
|
|
ps += L3_EXTRA_SIZE;
|
|
ctrl.parm.setup.si1 = 0;
|
|
ctrl.parm.setup.si2 = 0;
|
|
if (qi->bearer_capability) {
|
|
p = ps + qi->bearer_capability;
|
|
if ((p[1] > 1) && (p[1] < 11)) {
|
|
switch (p[2] & 0x7f) {
|
|
case 0x00: /* Speech */
|
|
case 0x10: /* 3.1 Khz audio */
|
|
ctrl.parm.setup.si1 = 1;
|
|
break;
|
|
case 0x08: /* Unrestricted digital information */
|
|
ctrl.parm.setup.si1 = 7;
|
|
if (qi->llc)
|
|
ctrl.parm.setup.si2 = DecodeSI2(ps + qi->llc);
|
|
break;
|
|
case 0x09: /* Restricted digital information */
|
|
ctrl.parm.setup.si1 = 2;
|
|
break;
|
|
case 0x11:
|
|
/* Unrestr. digital information with
|
|
* tones/announcements ( or 7 kHz audio)
|
|
*/
|
|
ctrl.parm.setup.si1 = 3;
|
|
break;
|
|
case 0x18: /* Video */
|
|
ctrl.parm.setup.si1 = 4;
|
|
break;
|
|
}
|
|
switch (p[3] & 0x7f) {
|
|
case 0x40: /* packed mode */
|
|
ctrl.parm.setup.si1 = 8;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if ((ctrl.parm.setup.si1 == 7) && (ctrl.parm.setup.si2 < 160))
|
|
test_and_set_bit(I4L_FLG_L1HDLC, &ch->Flags);
|
|
else
|
|
test_and_set_bit(I4L_FLG_L1TRANS, &ch->Flags);
|
|
i = 0;
|
|
if (qi->calling_nr) {
|
|
p = ps + qi->calling_nr + 1;
|
|
l = *p++;
|
|
ctrl.parm.setup.plan = *p;
|
|
l--;
|
|
if (!(*p & 0x80)) {
|
|
p++;
|
|
ctrl.parm.setup.screen = *p;
|
|
l--;
|
|
} else
|
|
ctrl.parm.setup.screen = 0;
|
|
p++;
|
|
while(i<l)
|
|
ctrl.parm.setup.eazmsn[i++] = *p++;
|
|
ctrl.parm.setup.eazmsn[i] = 0;
|
|
} else
|
|
ctrl.parm.setup.eazmsn[0] = 0;
|
|
if (qi->calling_sub) {
|
|
p = ps + qi->calling_sub + 1;
|
|
l = *p++;
|
|
l--;
|
|
p++;
|
|
if (l>0)
|
|
ctrl.parm.setup.eazmsn[i++] = '.';
|
|
while(l>0) {
|
|
ctrl.parm.setup.eazmsn[i++] = *p++;
|
|
l--;
|
|
}
|
|
ctrl.parm.setup.eazmsn[i] = 0;
|
|
}
|
|
i = 0;
|
|
if (qi->called_nr) {
|
|
p = ps + qi->called_nr + 1;
|
|
l = *p++;
|
|
p++;
|
|
l--;
|
|
while(i<l)
|
|
ctrl.parm.setup.phone[i++] = *p++;
|
|
ctrl.parm.setup.phone[i] = 0;
|
|
} else
|
|
ctrl.parm.setup.phone[0] = 0;
|
|
if (qi->called_sub) {
|
|
p = ps + qi->called_sub + 1;
|
|
l = *p++;
|
|
l--;
|
|
p++;
|
|
if (l>0)
|
|
ctrl.parm.setup.phone[i++] = '.';
|
|
while(l>0) {
|
|
ctrl.parm.setup.phone[i++] = *p++;
|
|
l--;
|
|
}
|
|
ctrl.parm.setup.phone[i] = 0;
|
|
}
|
|
if (test_bit(I4L_FLG_L1TRANS, &ch->Flags)) {
|
|
i4l_cmd(ch->drv, ch->nr | (ISDN_PROTO_L2_TRANS << 8), ISDN_CMD_SETL2);
|
|
i4l_cmd(ch->drv, ch->nr | (ISDN_PROTO_L3_TRANS << 8), ISDN_CMD_SETL3);
|
|
} else {
|
|
i4l_cmd(ch->drv, ch->nr | (ISDN_PROTO_L2_HDLC << 8), ISDN_CMD_SETL2);
|
|
i4l_cmd(ch->drv, ch->nr | (ISDN_PROTO_L3_TRANS << 8), ISDN_CMD_SETL3);
|
|
}
|
|
if (ch->drv->debug & 0x4)
|
|
printk(KERN_DEBUG "ocall from %s, si(%d/%d) -> %s\n", ctrl.parm.setup.eazmsn,
|
|
ctrl.parm.setup.si1, ctrl.parm.setup.si2, ctrl.parm.setup.phone);
|
|
ctrl.driver = ch->drv->idx;
|
|
ctrl.arg = ch->nr;
|
|
ctrl.command = ISDN_CMD_DIAL;
|
|
ch->drv->interface->command(&ctrl);
|
|
dev_kfree_skb(skb);
|
|
}
|
|
|
|
static void
|
|
capi_alert(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
struct sk_buff *skb = arg;
|
|
|
|
mISDN_FsmChangeState(fi, ST_ALERT);
|
|
i4l_cmd(ch->drv, ch->nr, ISDN_CMD_ALERT);
|
|
if (skb)
|
|
dev_kfree_skb(skb);
|
|
}
|
|
|
|
static void
|
|
capi_connect(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
struct sk_buff *skb = arg;
|
|
|
|
if (test_bit(I4L_FLG_L1TRANS, &ch->Flags)) {
|
|
i4l_cmd(ch->drv, ch->nr | (ISDN_PROTO_L2_TRANS << 8), ISDN_CMD_SETL2);
|
|
i4l_cmd(ch->drv, ch->nr | (ISDN_PROTO_L3_TRANS << 8), ISDN_CMD_SETL3);
|
|
} else {
|
|
i4l_cmd(ch->drv, ch->nr | (ISDN_PROTO_L2_HDLC << 8), ISDN_CMD_SETL2);
|
|
i4l_cmd(ch->drv, ch->nr | (ISDN_PROTO_L3_TRANS << 8), ISDN_CMD_SETL3);
|
|
}
|
|
mISDN_FsmChangeState(fi, ST_WAITDCONN);
|
|
i4l_cmd(ch->drv, ch->nr, ISDN_CMD_ACCEPTD);
|
|
if (skb)
|
|
dev_kfree_skb(skb);
|
|
}
|
|
|
|
static void
|
|
capi_disconnect(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
struct sk_buff *skb = arg;
|
|
|
|
mISDN_FsmChangeState(fi, ST_HANGUP);
|
|
test_and_set_bit(I4L_FLG_HANGUP, &ch->Flags);
|
|
i4l_cmd(ch->drv, ch->nr, ISDN_CMD_HANGUP);
|
|
if (skb)
|
|
dev_kfree_skb(skb);
|
|
}
|
|
|
|
static void
|
|
capi_release(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
struct sk_buff *skb = arg;
|
|
|
|
if (!test_and_clear_bit(I4L_FLG_HANGUP, &ch->Flags))
|
|
i4l_cmd(ch->drv, ch->nr, ISDN_CMD_HANGUP);
|
|
if (skb)
|
|
dev_kfree_skb(skb);
|
|
reset_channel(ch);
|
|
mISDN_FsmChangeState(fi, ST_NULL);
|
|
}
|
|
|
|
static void
|
|
capi_establishb(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
|
|
i4l_cmd(ch->drv, ch->nr, ISDN_CMD_ACCEPTB);
|
|
}
|
|
|
|
static void
|
|
capi_releaseb(struct FsmInst *fi, int event, void *arg)
|
|
{
|
|
i4l_channel_t *ch = fi->userdata;
|
|
|
|
test_and_clear_bit(I4L_FLG_BREADY, &ch->Flags);
|
|
mISDN_FsmChangeState(fi, ST_ACTIVD);
|
|
}
|
|
|
|
static int
|
|
Dchannel_i4l(mISDNif_t *hif, struct sk_buff *skb)
|
|
{
|
|
int i, ret = -EINVAL;
|
|
mISDN_head_t *hh;
|
|
i4l_capi_t *ic;
|
|
i4l_channel_t *ch;
|
|
|
|
if (!hif || !skb)
|
|
return(ret);
|
|
ic = hif->fdata;
|
|
hh = mISDN_HEAD_P(skb);
|
|
if (ic->debug & 0x2)
|
|
printk(KERN_DEBUG "%s: prim(%x) id(%x)\n", __FUNCTION__, hh->prim, hh->dinfo);
|
|
if (!ic)
|
|
return(ret);
|
|
if ((DL_ESTABLISH | REQUEST) == hh->prim) {
|
|
// FIXME
|
|
dev_kfree_skb(skb);
|
|
return(0);
|
|
}
|
|
ch = ic->ch;
|
|
for (i=0; i < ic->nr_ch; i++) {
|
|
if (ch->l4id == hh->dinfo)
|
|
break;
|
|
ch++;
|
|
}
|
|
if (i == ic->nr_ch)
|
|
ch = NULL;
|
|
if ((CC_NEW_CR | REQUEST) == hh->prim) {
|
|
if (ch) {
|
|
printk(KERN_WARNING "%s: ch%x in use\n", __FUNCTION__, ch->nr);
|
|
ret = -EBUSY;
|
|
} else {
|
|
ch = ic->ch;
|
|
for (i=0; i < ic->nr_ch; i++) {
|
|
if (ch->l4id == 0)
|
|
break;
|
|
ch++;
|
|
}
|
|
if (i == ic->nr_ch) {
|
|
ret = -EBUSY;
|
|
} else {
|
|
ch->l4id = hh->dinfo;
|
|
ret = 0;
|
|
dev_kfree_skb(skb);
|
|
}
|
|
}
|
|
return(ret);
|
|
}
|
|
if (!ch) {
|
|
printk(KERN_WARNING "%s: no channel prim(%x) id(%x)\n", __FUNCTION__, hh->prim, hh->dinfo);
|
|
return(ret);
|
|
}
|
|
if (ch->drv->debug & 0x4)
|
|
mISDN_LogL3Msg(skb);
|
|
switch(hh->prim) {
|
|
case CC_SETUP | REQUEST:
|
|
ret = mISDN_FsmEvent(&ch->i4lm, EV_CAPI_OCALL, skb);
|
|
break;
|
|
case CC_ALERTING | REQUEST:
|
|
ret = mISDN_FsmEvent(&ch->i4lm, EV_CAPI_ALERT, skb);
|
|
break;
|
|
case CC_CONNECT | REQUEST:
|
|
ret = mISDN_FsmEvent(&ch->i4lm, EV_CAPI_DCONNECT, skb);
|
|
break;
|
|
case CC_DISCONNECT | REQUEST:
|
|
case CC_RELEASE | REQUEST:
|
|
ret = mISDN_FsmEvent(&ch->i4lm, EV_CAPI_DISCONNECT, skb);
|
|
break;
|
|
case CC_RELEASE_COMPLETE | REQUEST:
|
|
ret = mISDN_FsmEvent(&ch->i4lm, EV_CAPI_RELEASE, skb);
|
|
break;
|
|
default:
|
|
if (debug)
|
|
printk(KERN_DEBUG "%s: ch%x prim(%x) id(%x) not handled\n",
|
|
__FUNCTION__, ch->nr, hh->prim, hh->dinfo);
|
|
break;
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
static int
|
|
Bchannel_i4l(mISDNif_t *hif, struct sk_buff *skb)
|
|
{
|
|
i4l_channel_t *ch;
|
|
int ret = -EINVAL;
|
|
mISDN_head_t *hh;
|
|
|
|
if (!hif || !skb)
|
|
return(ret);
|
|
ch = hif->fdata;
|
|
hh = mISDN_HEAD_P(skb);
|
|
if (ch->drv->debug & 0x20)
|
|
printk(KERN_DEBUG "%s: prim(%x)\n", __FUNCTION__, hh->prim);
|
|
switch(hh->prim) {
|
|
case PH_ACTIVATE | REQUEST:
|
|
case DL_ESTABLISH | REQUEST:
|
|
mISDN_FsmEvent(&ch->i4lm, EV_CAPI_ESTABLISHB, NULL);
|
|
skb_trim(skb, 0);
|
|
ret = if_newhead(&ch->inst.up, hh->prim | CONFIRM, 0, skb);
|
|
break;
|
|
case PH_DEACTIVATE | REQUEST:
|
|
case DL_RELEASE | REQUEST:
|
|
mISDN_FsmEvent(&ch->i4lm, EV_CAPI_RELEASEB, NULL);
|
|
skb_trim(skb, 0);
|
|
ret = if_newhead(&ch->inst.up, hh->prim | CONFIRM, 0, skb);
|
|
break;
|
|
case PH_DATA | REQUEST:
|
|
case DL_DATA | REQUEST:
|
|
skb_queue_tail(&ch->sendq, skb);
|
|
ret = sendqueued(ch);
|
|
break;
|
|
default:
|
|
if (debug)
|
|
printk(KERN_DEBUG "%s: ch%x prim(%x) id(%x) not handled\n",
|
|
__FUNCTION__, ch->nr, hh->prim, hh->dinfo);
|
|
break;
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
|
|
/*
|
|
* Receive a packet from B-Channel. (Called from low-level-module)
|
|
*/
|
|
static void
|
|
I4Lcapi_receive_skb_callback(int drvidx, int channel, struct sk_buff *skb)
|
|
{
|
|
i4l_capi_t *ic = drvmap[drvidx];
|
|
i4l_channel_t *ch;
|
|
mISDN_headext_t *hhe = mISDN_HEADEXT_P(skb);
|
|
int ret;
|
|
|
|
if (!ic) {
|
|
int_error();
|
|
return;
|
|
}
|
|
ch = ic->ch + channel;
|
|
if (!test_bit(I4L_FLG_BREADY, &ch->Flags)) {
|
|
if (ic->debug & 0x10)
|
|
printk(KERN_WARNING "I4Lcapi_receive_skb_callback: bc%d/%d not ready\n", channel, ch->nr);
|
|
dev_kfree_skb(skb);
|
|
return;
|
|
}
|
|
hhe->prim = test_bit(I4L_FLG_LAYER1, &ch->Flags) ? PH_DATA_IND : DL_DATA_IND;
|
|
if (!ch->inst.up.func) {
|
|
dev_kfree_skb(skb);
|
|
int_error();
|
|
return;
|
|
}
|
|
if (in_interrupt()) {
|
|
hhe->func.iff = ch->inst.up.func;
|
|
hhe->data[0] = &ch->inst.up;
|
|
ret = ch->inst.obj->ctrl(NULL, MGR_QUEUEIF | REQUEST, skb);
|
|
} else
|
|
ret = ch->inst.up.func(&ch->inst.up, skb);
|
|
if (ret)
|
|
dev_kfree_skb(skb);
|
|
}
|
|
|
|
static int
|
|
i4l_stat_run(i4l_capi_t *ic) {
|
|
int err;
|
|
|
|
err = I4Lcapi.ctrl(ic->inst.st, MGR_SETSTACK | REQUEST, &ic->pid);
|
|
if (err) {
|
|
printk(KERN_ERR "MGR_SETSTACK REQUEST dch err(%d)\n", err);
|
|
I4Lcapi.ctrl(ic->inst.st, MGR_DELSTACK | REQUEST, NULL);
|
|
return(err);
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
static int
|
|
i4l_sent_pkt(i4l_capi_t *drv, isdn_ctrl *c)
|
|
{
|
|
i4l_channel_t *ch = drv->ch;
|
|
struct sk_buff *skb;
|
|
int ret;
|
|
mISDN_headext_t *hhe;
|
|
|
|
if (c->arg < 0)
|
|
return -1;
|
|
ch += c->arg;
|
|
skb = skb_dequeue(&ch->ackq);
|
|
if (!skb) {
|
|
int_error();
|
|
return(-1);
|
|
}
|
|
if (drv->debug & 0x800)
|
|
printk(KERN_DEBUG "bc%ld ack skb(%p)\n", c->arg, skb);
|
|
if (skb_queue_len(&ch->sendq))
|
|
sendqueued(ch);
|
|
skb_trim(skb, 0);
|
|
hhe = mISDN_HEADEXT_P(skb);
|
|
hhe->prim |= CONFIRM;
|
|
if (in_interrupt()) {
|
|
hhe->func.iff = ch->inst.up.func;
|
|
hhe->data[0] = &ch->inst.up;
|
|
ret = ch->inst.obj->ctrl(NULL, MGR_QUEUEIF | REQUEST, skb);
|
|
} else
|
|
ret = ch->inst.up.func(&ch->inst.up, skb);
|
|
if (ret)
|
|
dev_kfree_skb(skb);
|
|
return(ret);
|
|
}
|
|
|
|
#define I4L_LOGBUF_SIZE 256
|
|
static char logbuf[I4L_LOGBUF_SIZE];
|
|
|
|
static int
|
|
i4l_stavail(i4l_capi_t *drv, isdn_ctrl *c)
|
|
{
|
|
int len = c->arg;
|
|
|
|
if (drv->interface->readstat) {
|
|
while(len>0) {
|
|
if (len < I4L_LOGBUF_SIZE) {
|
|
drv->interface->readstat(logbuf, len, 0, drv->idx, 0);
|
|
logbuf[len] = 0;
|
|
} else {
|
|
drv->interface->readstat(logbuf, I4L_LOGBUF_SIZE - 1, 0, drv->idx, 0);
|
|
logbuf[I4L_LOGBUF_SIZE] = 0;
|
|
}
|
|
if (drv->debug & 0x1)
|
|
printk(KERN_DEBUG "%s", logbuf);
|
|
len -= (I4L_LOGBUF_SIZE -1);
|
|
}
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
static int
|
|
I4Lcapi_status_callback(isdn_ctrl *c)
|
|
{
|
|
i4l_capi_t *drv = drvmap[c->driver];
|
|
i4l_channel_t *ch;
|
|
int i, ret = -1;
|
|
|
|
if (!drv)
|
|
return(-1);
|
|
if (c->command == ISDN_STAT_BSENT)
|
|
return(i4l_sent_pkt(drv, c));
|
|
if (c->command == ISDN_STAT_STAVAIL)
|
|
return(i4l_stavail(drv, c));
|
|
ch = drv->ch;
|
|
if (drv->debug & 0x8)
|
|
printk(KERN_DEBUG "drv%d cmd(%d) arg(%ld)\n",
|
|
c->driver, c->command, c->arg);
|
|
switch (c->command) {
|
|
case ISDN_STAT_RUN:
|
|
ret = i4l_stat_run(drv);
|
|
break;
|
|
case ISDN_STAT_STOP:
|
|
// FIXME
|
|
ret = 0;
|
|
break;
|
|
case ISDN_STAT_ICALL:
|
|
if (c->arg < 0)
|
|
return -1;
|
|
ch += c->arg;
|
|
ret = mISDN_FsmEvent(&ch->i4lm, EV_I4L_ICALL, &c->parm.setup);
|
|
break;
|
|
case ISDN_STAT_CINF:
|
|
if (c->arg < 0)
|
|
return -1;
|
|
// FIXME
|
|
ret = 0;
|
|
break;
|
|
case ISDN_STAT_CAUSE:
|
|
if (c->arg < 0)
|
|
return -1;
|
|
ch += c->arg;
|
|
if ((c->parm.num[0] == 'E') || (c->parm.num[0] == 'L'))
|
|
i = 1;
|
|
else
|
|
i = 0;
|
|
sscanf(&c->parm.num[i], "%2X%2X", &ch->cause_loc, &ch->cause_val);
|
|
ch->cause_loc |= 0x80;
|
|
ch->cause_val |= 0x80;
|
|
if (drv->debug & 0x1)
|
|
printk(KERN_DEBUG "isdn: ch%ld cause: %s %02x%02x\n",
|
|
c->arg, c->parm.num, ch->cause_loc, ch->cause_val);
|
|
ret = 0;
|
|
break;
|
|
case ISDN_STAT_DISPLAY:
|
|
// FIXME
|
|
ret = 0;
|
|
break;
|
|
case ISDN_STAT_DCONN:
|
|
if (c->arg < 0)
|
|
return -1;
|
|
ch += c->arg;
|
|
ret = mISDN_FsmEvent(&ch->i4lm, EV_I4L_DCONN, NULL);
|
|
break;
|
|
case ISDN_STAT_DHUP:
|
|
if (c->arg < 0)
|
|
return -1;
|
|
ch += c->arg;
|
|
ret = mISDN_FsmEvent(&ch->i4lm, EV_I4L_DHUP, NULL);
|
|
break;
|
|
case ISDN_STAT_BCONN:
|
|
if (c->arg < 0)
|
|
return -1;
|
|
ch += c->arg;
|
|
ret = mISDN_FsmEvent(&ch->i4lm, EV_I4L_BCONN, NULL);
|
|
break;
|
|
case ISDN_STAT_BHUP:
|
|
if (c->arg < 0)
|
|
return -1;
|
|
ch += c->arg;
|
|
ret = mISDN_FsmEvent(&ch->i4lm, EV_I4L_BHUP, NULL);
|
|
break;
|
|
case ISDN_STAT_NODCH:
|
|
case ISDN_STAT_L1ERR:
|
|
if (c->arg < 0)
|
|
return -1;
|
|
ch += c->arg;
|
|
ret = mISDN_FsmEvent(&ch->i4lm, EV_I4L_L1ERR, NULL);
|
|
break;
|
|
case ISDN_STAT_ADDCH:
|
|
case ISDN_STAT_DISCH:
|
|
// FIXME
|
|
ret = 0;
|
|
break;
|
|
case ISDN_STAT_UNLOAD:
|
|
ret = I4Lcapi.ctrl(drv->inst.st, MGR_DELSTACK | REQUEST, NULL);
|
|
MOD_DEC_USE_COUNT;
|
|
break;
|
|
case CAPI_PUT_MESSAGE:
|
|
// FIXME
|
|
break;
|
|
case ISDN_STAT_FAXIND:
|
|
// FIXME
|
|
break;
|
|
case ISDN_STAT_AUDIO:
|
|
// FIXME
|
|
break;
|
|
case ISDN_STAT_PROT:
|
|
case ISDN_STAT_REDIR:
|
|
// FIXME
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return(ret);
|
|
}
|
|
|
|
static int
|
|
I4Lcapi_manager(void *data, u_int prim, void *arg) {
|
|
i4l_capi_t *card = I4Lcapi.ilist;
|
|
mISDNinstance_t *inst = data;
|
|
i4l_channel_t *channel = NULL;
|
|
int nr_ch = -2;
|
|
|
|
if (debug & 0x100)
|
|
printk(KERN_DEBUG "%s: data:%p prim:%x arg:%p\n",
|
|
__FUNCTION__, data, prim, arg);
|
|
if (prim == (MGR_HASPROTOCOL | REQUEST))
|
|
return(mISDN_HasProtocolP(&I4Lcapi, arg));
|
|
if (!data) {
|
|
printk(KERN_ERR "I4Lcapi_manager no data prim %x arg %p\n",
|
|
prim, arg);
|
|
return(-EINVAL);
|
|
}
|
|
while(card) {
|
|
if (&card->inst == inst) {
|
|
nr_ch = -1;
|
|
break;
|
|
}
|
|
channel = card->ch;
|
|
for (nr_ch = 0; nr_ch < card->nr_ch; nr_ch++) {
|
|
if (&channel->inst == inst)
|
|
break;
|
|
channel++;
|
|
}
|
|
if (nr_ch != card->nr_ch)
|
|
break;
|
|
card = card->next;
|
|
channel = NULL;
|
|
nr_ch = -2;
|
|
}
|
|
if (nr_ch == -2) {
|
|
printk(KERN_ERR "I4Lcapi_manager no channel data %p prim %x arg %p\n",
|
|
data, prim, arg);
|
|
return(-EINVAL);
|
|
}
|
|
switch(prim) {
|
|
case MGR_REGLAYER | CONFIRM:
|
|
break;
|
|
case MGR_UNREGLAYER | REQUEST:
|
|
I4Lcapi.ctrl(inst->up.peer, MGR_DISCONNECT | REQUEST, &inst->up);
|
|
I4Lcapi.ctrl(inst, MGR_UNREGLAYER | REQUEST, NULL);
|
|
break;
|
|
case MGR_RELEASE | INDICATION:
|
|
if (nr_ch == -1) {
|
|
release_card(card->idx);
|
|
} else {
|
|
I4Lcapi.refcnt--;
|
|
}
|
|
break;
|
|
case MGR_CONNECT | REQUEST:
|
|
return(mISDN_ConnectIF(inst, arg));
|
|
case MGR_SETIF | REQUEST:
|
|
case MGR_SETIF | INDICATION:
|
|
if (nr_ch == -1)
|
|
return(mISDN_SetIF(inst, arg, prim, Dchannel_i4l, NULL, card));
|
|
else
|
|
return(mISDN_SetIF(inst, arg, prim, Bchannel_i4l, NULL, channel));
|
|
case MGR_DISCONNECT | REQUEST:
|
|
case MGR_DISCONNECT | INDICATION:
|
|
return(mISDN_DisConnectIF(inst, arg));
|
|
case MGR_SETSTACK | INDICATION:
|
|
if (nr_ch >= 0) {
|
|
if (inst->pid.protocol[2] != ISDN_PID_L2_B_TRANS)
|
|
test_and_set_bit(I4L_FLG_LAYER1, &channel->Flags);
|
|
mISDN_FsmEvent(&channel->i4lm, EV_STACKREADY, NULL);
|
|
}
|
|
break;
|
|
default:
|
|
if (debug)
|
|
printk(KERN_DEBUG "I4Lcapi_manager prim %x not handled\n", prim);
|
|
return(-EINVAL);
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
static i4l_capi_reg_t I4Lcapireg;
|
|
|
|
static int
|
|
I4Lcapi_register(isdn_if *iif)
|
|
{
|
|
int drvidx = 0;
|
|
int i, err;
|
|
i4l_channel_t *ch;
|
|
|
|
if (!iif->writebuf_skb) {
|
|
printk(KERN_ERR "I4Lcapi_register: No write routine given.\n");
|
|
return 0;
|
|
}
|
|
for (drvidx=0; drvidx<MAX_CARDS; drvidx++) {
|
|
if (drvmap[drvidx] == NULL)
|
|
break;
|
|
}
|
|
if (drvidx == MAX_CARDS) {
|
|
printk(KERN_ERR "I4Lcapi_register: no driver slot this card\n");
|
|
return(0);
|
|
}
|
|
drvmap[drvidx] = kmalloc(sizeof(i4l_capi_t), GFP_KERNEL);
|
|
if (!drvmap[drvidx]) {
|
|
printk(KERN_ERR "I4Lcapi_register: no memory for i4l_capi_t\n");
|
|
return(0);
|
|
}
|
|
memset(drvmap[drvidx], 0, sizeof(i4l_capi_t));
|
|
drvmap[drvidx]->ch = kmalloc(iif->channels * sizeof(i4l_channel_t), GFP_KERNEL);
|
|
if (!drvmap[drvidx]->ch) {
|
|
printk(KERN_ERR "I4Lcapi_register: no memory for i4l_channel_t\n");
|
|
kfree(drvmap[drvidx]);
|
|
drvmap[drvidx] = NULL;
|
|
return(0);
|
|
}
|
|
drvmap[drvidx]->idx = drvidx;
|
|
drvmap[drvidx]->interface = iif;
|
|
drvmap[drvidx]->nr_ch = iif->channels;
|
|
iif->channels = drvidx;
|
|
|
|
iif->rcvcallb_skb = I4Lcapi_receive_skb_callback;
|
|
iif->statcallb = I4Lcapi_status_callback;
|
|
|
|
APPEND_TO_LIST(drvmap[drvidx], ((i4l_capi_t *)I4Lcapi.ilist));
|
|
drvmap[drvidx]->debug = debug;
|
|
drvmap[drvidx]->inst.pid.layermask = ISDN_LAYER(0) | ISDN_LAYER(1) | ISDN_LAYER(2) | ISDN_LAYER(3);
|
|
drvmap[drvidx]->inst.pid.protocol[0] = ISDN_PID_L0_TE_S0;
|
|
drvmap[drvidx]->inst.pid.protocol[1] = ISDN_PID_L1_TE_S0;
|
|
drvmap[drvidx]->inst.pid.protocol[2] = ISDN_PID_L2_LAPD;
|
|
drvmap[drvidx]->inst.pid.protocol[3] = ISDN_PID_L3_DSS1USER;
|
|
mISDN_init_instance(&drvmap[drvidx]->inst, &I4Lcapi, drvmap[drvidx]);
|
|
sprintf(drvmap[drvidx]->inst.name, "Fritz%d", drvidx+1);
|
|
mISDN_set_dchannel_pid(&drvmap[drvidx]->pid, 2, 0);
|
|
for (i=0; i < drvmap[drvidx]->nr_ch; i++) {
|
|
init_channel(drvmap[drvidx], i);
|
|
}
|
|
err = I4Lcapi.ctrl(NULL, MGR_NEWSTACK | REQUEST, &drvmap[drvidx]->inst);
|
|
if (err) {
|
|
release_card(drvidx);
|
|
return(err);
|
|
}
|
|
ch = drvmap[drvidx]->ch;
|
|
for (i=0; i < drvmap[drvidx]->nr_ch; i++) {
|
|
err = I4Lcapi.ctrl(drvmap[drvidx]->inst.st, MGR_NEWSTACK | REQUEST, &ch->inst);
|
|
if (err) {
|
|
printk(KERN_ERR "MGR_ADDSTACK bchan error %d\n", err);
|
|
I4Lcapi.ctrl(drvmap[drvidx]->inst.st, MGR_DELSTACK | REQUEST, NULL);
|
|
return(err);
|
|
}
|
|
ch++;
|
|
}
|
|
MOD_INC_USE_COUNT;
|
|
return(1);
|
|
}
|
|
|
|
static struct FsmNode I4LFnList[] =
|
|
{
|
|
{ST_NULL, EV_I4L_ICALL, i4l_icall},
|
|
{ST_NULL, EV_CAPI_OCALL, capi_ocall},
|
|
{ST_ICALL, EV_I4L_DHUP, i4l_dhup},
|
|
{ST_ICALL, EV_I4L_L1ERR, i4l_l1err},
|
|
{ST_ICALL, EV_CAPI_ALERT, capi_alert},
|
|
{ST_ICALL, EV_CAPI_DCONNECT, capi_connect},
|
|
{ST_ICALL, EV_CAPI_DISCONNECT, capi_disconnect},
|
|
{ST_ICALL, EV_CAPI_RELEASE, capi_release},
|
|
{ST_OCALL, EV_I4L_DHUP, i4l_dhup},
|
|
{ST_OCALL, EV_I4L_L1ERR, i4l_l1err},
|
|
{ST_OCALL, EV_CAPI_DISCONNECT, capi_disconnect},
|
|
{ST_OCALL, EV_CAPI_RELEASE, capi_release},
|
|
{ST_OCALL, EV_I4L_DCONN, i4l_dconn_out},
|
|
{ST_PROCEED, EV_I4L_DHUP, i4l_dhup},
|
|
{ST_PROCEED, EV_I4L_L1ERR, i4l_l1err},
|
|
{ST_PROCEED, EV_CAPI_ALERT, capi_alert},
|
|
{ST_PROCEED, EV_CAPI_DCONNECT, capi_connect},
|
|
{ST_PROCEED, EV_CAPI_DISCONNECT, capi_disconnect},
|
|
{ST_PROCEED, EV_CAPI_RELEASE, capi_release},
|
|
{ST_ALERT, EV_I4L_DHUP, i4l_dhup},
|
|
{ST_ALERT, EV_I4L_L1ERR, i4l_l1err},
|
|
{ST_ALERT, EV_CAPI_DCONNECT, capi_connect},
|
|
{ST_ALERT, EV_CAPI_DISCONNECT, capi_disconnect},
|
|
{ST_ALERT, EV_CAPI_RELEASE, capi_release},
|
|
{ST_WAITDCONN, EV_I4L_DCONN, i4l_dconn_in},
|
|
{ST_WAITDCONN, EV_CAPI_DISCONNECT, capi_disconnect},
|
|
{ST_WAITDCONN, EV_CAPI_RELEASE, capi_release},
|
|
{ST_WAITDCONN, EV_I4L_DHUP, i4l_dhup},
|
|
{ST_ACTIVD, EV_I4L_DHUP, i4l_dhup},
|
|
{ST_ACTIVD, EV_I4L_L1ERR, i4l_l1err},
|
|
{ST_ACTIVD, EV_CAPI_DISCONNECT, capi_disconnect},
|
|
{ST_ACTIVD, EV_CAPI_RELEASE, capi_release},
|
|
{ST_ACTIVD, EV_I4L_BCONN, i4l_bconn_notready},
|
|
{ST_ACTIVD, EV_STACKREADY, stackready},
|
|
{ST_BREADY, EV_CAPI_ESTABLISHB, capi_establishb},
|
|
{ST_BREADY, EV_I4L_BCONN, i4l_bconn},
|
|
{ST_BREADY, EV_I4L_DHUP, i4l_dhup},
|
|
{ST_BREADY, EV_I4L_BHUP, i4l_bhup},
|
|
{ST_BREADY, EV_I4L_L1ERR, i4l_l1err},
|
|
{ST_BREADY, EV_CAPI_RELEASEB, capi_releaseb},
|
|
{ST_BREADY, EV_CAPI_DISCONNECT, capi_disconnect},
|
|
{ST_BREADY, EV_CAPI_RELEASE, capi_release},
|
|
{ST_ACTIVB, EV_I4L_DHUP, i4l_dhup},
|
|
{ST_ACTIVB, EV_I4L_BHUP, i4l_bhup},
|
|
{ST_ACTIVB, EV_I4L_L1ERR, i4l_l1err},
|
|
{ST_ACTIVB, EV_CAPI_DISCONNECT, capi_disconnect},
|
|
{ST_ACTIVB, EV_CAPI_RELEASE, capi_release},
|
|
{ST_ACTIVB, EV_CAPI_RELEASEB, capi_releaseb},
|
|
{ST_HANGUP, EV_I4L_DHUP, i4l_dhup},
|
|
{ST_HANGUP, EV_I4L_L1ERR, i4l_l1err},
|
|
{ST_HANGUP, EV_CAPI_RELEASE, capi_release},
|
|
};
|
|
|
|
#define I4L_FN_COUNT (sizeof(I4LFnList)/sizeof(struct FsmNode))
|
|
|
|
static char *I4L_capi_name = "I4L CAPI";
|
|
|
|
int
|
|
I4Lcapi_init(void)
|
|
{
|
|
int err;
|
|
|
|
printk(KERN_INFO "I4L CAPI interface modul version %s\n", mISDN_getrev(i4lcapi_revision));
|
|
#ifdef MODULE
|
|
I4Lcapi.owner = THIS_MODULE;
|
|
#endif
|
|
I4Lcapi.name = I4L_capi_name;
|
|
I4Lcapi.own_ctrl = I4Lcapi_manager;
|
|
I4Lcapi.DPROTO.protocol[0] = ISDN_PID_L0_TE_S0;
|
|
I4Lcapi.DPROTO.protocol[1] = ISDN_PID_L1_TE_S0;
|
|
I4Lcapi.DPROTO.protocol[2] = ISDN_PID_L2_LAPD | ISDN_PID_L2_DF_PTP;
|
|
I4Lcapi.DPROTO.protocol[3] = ISDN_PID_L3_DSS1USER | ISDN_PID_L3_DF_PTP;
|
|
I4Lcapi.BPROTO.protocol[1] = ISDN_PID_L1_B_64TRANS | ISDN_PID_L1_B_64HDLC;
|
|
I4Lcapi.BPROTO.protocol[2] = ISDN_PID_L2_B_TRANS;
|
|
I4Lcapi.prev = NULL;
|
|
I4Lcapi.next = NULL;
|
|
|
|
i4lfsm_s.state_count = STATE_COUNT;
|
|
i4lfsm_s.event_count = EVENT_COUNT;
|
|
i4lfsm_s.strEvent = strI4LEvent;
|
|
i4lfsm_s.strState = strI4LState;
|
|
mISDN_FsmNew(&i4lfsm_s, I4LFnList, I4L_FN_COUNT);
|
|
if ((err = mISDN_register(&I4Lcapi))) {
|
|
printk(KERN_ERR "Can't register I4L CAPI error(%d)\n", err);
|
|
mISDN_FsmFree(&i4lfsm_s);
|
|
return(err);
|
|
}
|
|
I4Lcapireg.register_func = I4Lcapi_register;
|
|
strcpy(I4Lcapireg.name, "I4L CAPI");
|
|
err = register_i4lcapi(&I4Lcapireg);
|
|
printk(KERN_INFO "registered I4L CAPI %s err(%d)\n", i4lcapi_revision, err);
|
|
return(0);
|
|
}
|
|
|
|
#ifdef MODULE
|
|
void
|
|
I4Lcapi_cleanup(void)
|
|
{
|
|
|
|
int err;
|
|
if ((err = mISDN_unregister(&I4Lcapi))) {
|
|
printk(KERN_ERR "Can't unregister I4Lcapi error(%d)\n", err);
|
|
return;
|
|
}
|
|
while(I4Lcapi.ilist) {
|
|
printk(KERN_ERR "I4Lcapi card struct not empty refs %d\n",
|
|
I4Lcapi.refcnt);
|
|
release_card(((i4l_capi_t *)I4Lcapi.ilist)->idx);
|
|
}
|
|
mISDN_FsmFree(&i4lfsm_s);
|
|
unregister_i4lcapi();
|
|
return;
|
|
}
|
|
|
|
module_init(I4Lcapi_init);
|
|
module_exit(I4Lcapi_cleanup);
|
|
|
|
#endif
|