static void
up1tr6(struct PStack *st, int pr, void *arg)
{
int i, mt;
struct sk_buff *skb = arg;
char tmp[80];
if ((skb->data[0] & 0xfe) != PROTO_DIS_N0) {
if (st->l3.debug & L3_DEB_PROTERR) {
sprintf(tmp, "up1tr6%sunexpected discriminator %x message len %ld state %d",
(pr == DL_DATA) ? " " : "(broadcast) ",
skb->data[0], skb->len, st->l3.state);
l3_debug(st, tmp);
}
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
return;
}
mt = skb->data[skb->data[1] + 2];
if (skb->data[0] == PROTO_DIS_N0) {
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
if (st->l3.debug & L3_DEB_STATE) {
sprintf(tmp, "up1tr6%s N0 state %d mt %x unhandled",
(pr == DL_DATA) ? " " : "(broadcast) ",
st->l3.state, mt);
l3_debug(st, tmp);
}
} else if (skb->data[0] == PROTO_DIS_N1) {
for (i = 0; i < datastln1_len; i++)
if ((mt == datastln1[i].primitive) &&
((1 << st->l3.state) & datastln1[i].state))
break;
if (i == datastln1_len) {
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
if (st->l3.debug & L3_DEB_STATE) {
sprintf(tmp, "up1tr6%sstate %d mt %x unhandled",
(pr == DL_DATA) ? " " : "(broadcast) ",
st->l3.state, mt);
l3_debug(st, tmp);
}
return;
} else {
if (st->l3.debug & L3_DEB_STATE) {
sprintf(tmp, "up1tr6%sstate %d mt %x",
(pr == DL_DATA) ? " " : "(broadcast) ",
st->l3.state, mt);
l3_debug(st, tmp);
}
datastln1[i].rout(st, pr, skb);
}
}
}
static void
l3_1tr6_setup(struct PStack *st, u_char pr, void *arg)
{
u_char *p;
int bcfound = 0;
char tmp[80];
struct sk_buff *skb = arg;
p = skb->data;
st->pa->callref = getcallref(p);
st->l3.callref = 0x80 + st->pa->callref;
/* Channel Identification */
p = skb->data;
if ((p = findie(p, skb->len, WE0_chanID, 0))) {
st->pa->bchannel = p[2] & 0x3;
bcfound++;
} else if (st->l3.debug & L3_DEB_WARN)
l3_debug(st, "setup without bchannel");
p = skb->data;
if ((p = findie(p, skb->len, WE6_serviceInd, 6))) {
st->pa->setup.si1 = p[2];
st->pa->setup.si2 = p[3];
} else if (st->l3.debug & L3_DEB_WARN)
l3_debug(st, "setup without service indicator");
p = skb->data;
if ((p = findie(p, skb->len, WE0_destAddr, 0)))
iecpy(st->pa->setup.eazmsn, p, 1);
else
st->pa->setup.eazmsn[0] = 0;
p = skb->data;
if ((p = findie(p, skb->len, WE0_origAddr, 0))) {
iecpy(st->pa->setup.phone, p, 1);
} else
st->pa->setup.phone[0] = 0;
p = skb->data;
st->pa->spv = 0;
if ((p = findie(p, skb->len, WE0_netSpecFac, 0))) {
if ((FAC_SPV == p[3]) || (FAC_Activate == p[3]))
st->pa->spv = 1;
}
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
/* Signal all services, linklevel takes care of Service-Indicator */
if (bcfound) {
if ((st->pa->setup.si1 != 7) && (st->l3.debug & L3_DEB_WARN)) {
sprintf(tmp, "non-digital call: %s -> %s",
st->pa->setup.phone,
st->pa->setup.eazmsn);
l3_debug(st, tmp);
}
newl3state(st, 6);
st->l3.l3l4(st, CC_SETUP_IND, NULL);
}
}
static void
l3_1tr6_rel(struct PStack *st, u_char pr, void *arg)
{
struct sk_buff *skb = arg;
u_char *p;
p = skb->data;
if ((p = findie(p, skb->len, WE0_cause, 0))) {
if (p[1] > 0) {
st->pa->cause = p[2];
if (p[1] > 1)
st->pa->loc = p[3];
else
st->pa->loc = 0;
} else {
st->pa->cause = 0;
st->pa->loc = 0;
}
} else
st->pa->cause = -1;
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
StopAllL3Timer(st);
newl3state(st, 0);
l3_1TR6_message(st, MT_N1_REL_ACK, PROTO_DIS_N1);
st->l3.l3l4(st, CC_RELEASE_IND, NULL);
}
static void
l3_1tr6_info(struct PStack *st, u_char pr, void *arg)
{
u_char *p;
int i, tmpcharge = 0;
char a_charge[8], tmp[32];
struct sk_buff *skb = arg;
p = skb->data;
if ((p = findie(p, skb->len, WE6_chargingInfo, 6))) {
iecpy(a_charge, p, 1);
for (i = 0; i < strlen(a_charge); i++) {
tmpcharge *= 10;
tmpcharge += a_charge[i] & 0xf;
}
if (tmpcharge > st->pa->chargeinfo) {
st->pa->chargeinfo = tmpcharge;
st->l3.l3l4(st, CC_INFO_CHARGE, NULL);
}
if (st->l3.debug & L3_DEB_CHARGE) {
sprintf(tmp, "charging info %d", st->pa->chargeinfo);
l3_debug(st, tmp);
}
} else if (st->l3.debug & L3_DEB_CHARGE)
l3_debug(st, "charging info not found");
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
}
static void
l3_1tr6_info_s2(struct PStack *st, u_char pr, void *arg)
{
struct sk_buff *skb = arg;
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
}
static void
l3_1tr6_alert(struct PStack *st, u_char pr, void *arg)
{
struct sk_buff *skb = arg;
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
L3DelTimer(&st->l3.timer); /* T304 */
newl3state(st, 4);
st->l3.l3l4(st, CC_ALERTING_IND, NULL);
}
static void
l3_1tr6_connect_ack(struct PStack *st, u_char pr, void *arg)
{
struct sk_buff *skb = arg;
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
newl3state(st, 10);
st->pa->chargeinfo = 0;
L3DelTimer(&st->l3.timer);
st->l3.l3l4(st, CC_SETUP_COMPLETE_IND, NULL);
}
static void
l3_1tr6_rel_ack(struct PStack *st, u_char pr, void *arg)
{
struct sk_buff *skb = arg;
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
StopAllL3Timer(st);
newl3state(st, 0);
st->pa->cause = -1;
st->l3.l3l4(st, CC_RELEASE_CNF, NULL);
}
struct sk_buff *
l3_alloc_skb(int len)
{
struct sk_buff *skb;
if (!(skb = alloc_skb(len + MAX_HEADER_LEN, GFP_ATOMIC))) {
printk(KERN_WARNING "HiSax: No skb for D-channel\n");
return (NULL);
}
SET_SKB_FREE(skb);
skb_reserve(skb, MAX_HEADER_LEN);
return (skb);
}
static void
l3_1tr6_disc(struct PStack *st, u_char pr, void *arg)
{
struct sk_buff *skb = arg;
u_char *p;
int i, tmpcharge = 0;
char a_charge[8], tmp[32];
StopAllL3Timer(st);
p = skb->data;
if ((p = findie(p, skb->len, WE6_chargingInfo, 6))) {
iecpy(a_charge, p, 1);
for (i = 0; i < strlen(a_charge); i++) {
tmpcharge *= 10;
tmpcharge += a_charge[i] & 0xf;
}
if (tmpcharge > st->pa->chargeinfo) {
st->pa->chargeinfo = tmpcharge;
st->l3.l3l4(st, CC_INFO_CHARGE, NULL);
}
if (st->l3.debug & L3_DEB_CHARGE) {
sprintf(tmp, "charging info %d", st->pa->chargeinfo);
l3_debug(st, tmp);
}
} else if (st->l3.debug & L3_DEB_CHARGE)
l3_debug(st, "charging info not found");
p = skb->data;
if ((p = findie(p, skb->len, WE0_cause, 0))) {
if (p[1] > 0) {
st->pa->cause = p[2];
if (p[1] > 1)
st->pa->loc = p[3];
else
st->pa->loc = 0;
} else {
st->pa->cause = 0;
st->pa->loc = 0;
}
} else {
if (st->l3.debug & L3_DEB_WARN)
l3_debug(st, "cause not found");
st->pa->cause = -1;
}
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
newl3state(st, 12);
st->l3.l3l4(st, CC_DISCONNECT_IND, NULL);
}
static void
l3_1tr6_call_sent(struct PStack *st, u_char pr, void *arg)
{
u_char *p;
struct sk_buff *skb = arg;
L3DelTimer(&st->l3.timer);
p = skb->data;
if ((p = findie(p, skb->len, WE0_chanID, 0))) {
st->pa->bchannel = p[2] & 0x3;
} else if (st->l3.debug & L3_DEB_WARN)
l3_debug(st, "setup answer without bchannel");
SET_SKB_FREE(skb);
dev_kfree_skb(skb, FREE_READ);
L3AddTimer(&st->l3.timer, st->l3.t310, CC_T310);
newl3state(st, 3);
st->l3.l3l4(st, CC_PROCEEDING_IND, NULL);
}
static inline void
isac_interrupt(struct IsdnCardState *sp, u_char val)
{
u_char exval;
struct sk_buff *skb;
unsigned int count;
char tmp[32];
if (sp->debug & L1_DEB_ISAC) {
sprintf(tmp, "ISAC interrupt %x", val);
debugl1(sp, tmp);
}
if (val & 0x80) { /* RME */
exval = IsacReadReg(sp->isac, ISAC_RSTA);
if ((exval & 0x70) != 0x20) {
if (exval & 0x40)
if (sp->debug & L1_DEB_WARN)
debugl1(sp, "ISAC RDO");
if (!(exval & 0x20))
if (sp->debug & L1_DEB_WARN)
debugl1(sp, "ISAC CRC error");
IsacWriteReg(sp->isac, ISAC_CMDR, 0x80);
} else {
count = IsacReadReg(sp->isac, ISAC_RBCL) & 0x1f;
if (count == 0)
count = 32;
isac_empty_fifo(sp, count);
if ((count = sp->rcvidx) > 0) {
sp->rcvidx = 0;
if (!(skb = alloc_skb(count, GFP_ATOMIC)))
printk(KERN_WARNING "IX1: D receive out of memory\n");
else {
SET_SKB_FREE(skb);
memcpy(skb_put(skb, count), sp->rcvbuf, count);
skb_queue_tail(&sp->rq, skb);
}
}
}
sp->rcvidx = 0;
isac_sched_event(sp, ISAC_RCVBUFREADY);
}
if (val & 0x40) { /* RPF */
isac_empty_fifo(sp, 32);
}
if (val & 0x20) { /* RSC */
/* never */
if (sp->debug & L1_DEB_WARN)
debugl1(sp, "ISAC RSC interrupt");
}
if (val & 0x10) { /* XPR */
if (sp->tx_skb)
if (sp->tx_skb->len) {
isac_fill_fifo(sp);
goto afterXPR;
} else {
dev_kfree_skb(sp->tx_skb, FREE_WRITE);
sp->tx_cnt = 0;
sp->tx_skb = NULL;
}
if ((sp->tx_skb = skb_dequeue(&sp->sq))) {
sp->tx_cnt = 0;
isac_fill_fifo(sp);
} else
isac_sched_event(sp, ISAC_XMTBUFREADY);
}
afterXPR:
if (val & 0x04) { /* CISQ */
sp->ph_state = (IsacReadReg(sp->isac, ISAC_CIX0) >> 2)
& 0xf;
if (sp->debug & L1_DEB_ISAC) {
sprintf(tmp, "l1state %d", sp->ph_state);
debugl1(sp, tmp);
}
isac_new_ph(sp);
}
static
int receive_dmsg(struct IsdnCardState *cs)
{
struct sk_buff *skb;
long flags;
int idx;
int rcnt, z1, z2;
u_char stat, cip, f1, f2;
int chksum;
int count=5;
u_char *ptr;
save_flags(flags);
cli();
if (test_and_set_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags)) {
debugl1(cs, "rec_dmsg blocked");
restore_flags(flags);
return(1);
}
SelFiFo(cs, 4 | HFCD_REC);
cip = HFCD_FIFO | HFCD_F1 | HFCD_REC;
WaitNoBusy(cs);
f1 = cs->readisac(cs, cip) & 0xf;
cip = HFCD_FIFO | HFCD_F2 | HFCD_REC;
WaitNoBusy(cs);
f2 = cs->readisac(cs, cip) & 0xf;
while ((f1 != f2) && count--) {
z1 = ReadZReg(cs, HFCD_FIFO | HFCD_Z1 | HFCD_REC);
z2 = ReadZReg(cs, HFCD_FIFO | HFCD_Z2 | HFCD_REC);
rcnt = z1 - z2;
if (rcnt < 0)
rcnt += cs->hw.hfcD.dfifosize;
rcnt++;
if (cs->debug & L1_DEB_ISAC)
debugl1(cs, "hfcd recd f1(%d) f2(%d) z1(%x) z2(%x) cnt(%d)",
f1, f2, z1, z2, rcnt);
sti();
idx = 0;
cip = HFCD_FIFO | HFCD_FIFO_OUT | HFCD_REC;
if (rcnt > MAX_DFRAME_LEN + 3) {
if (cs->debug & L1_DEB_WARN)
debugl1(cs, "empty_fifo d: incoming packet too large");
while (idx < rcnt) {
cli();
if (!(WaitNoBusy(cs)))
break;
ReadReg(cs, HFCD_DATA_NODEB, cip);
sti();
idx++;
}
} else if (rcnt < 4) {
if (cs->debug & L1_DEB_WARN)
debugl1(cs, "empty_fifo d: incoming packet too small");
cli();
while ((idx++ < rcnt) && WaitNoBusy(cs))
ReadReg(cs, HFCD_DATA_NODEB, cip);
} else if ((skb = dev_alloc_skb(rcnt - 3))) {
SET_SKB_FREE(skb);
ptr = skb_put(skb, rcnt - 3);
while (idx < (rcnt - 3)) {
cli();
if (!(WaitNoBusy(cs)))
break;
*ptr = ReadReg(cs, HFCD_DATA_NODEB, cip);
sti();
idx++;
ptr++;
}
if (idx != (rcnt - 3)) {
sti();
debugl1(cs, "RFIFO D BUSY error");
printk(KERN_WARNING "HFC DFIFO channel BUSY Error\n");
dev_kfree_skb(skb, FREE_READ);
skb = NULL;
} else {
cli();
WaitNoBusy(cs);
chksum = (ReadReg(cs, HFCD_DATA, cip) << 8);
WaitNoBusy(cs);
chksum += ReadReg(cs, HFCD_DATA, cip);
WaitNoBusy(cs);
stat = ReadReg(cs, HFCD_DATA, cip);
sti();
if (cs->debug & L1_DEB_ISAC)
debugl1(cs, "empty_dfifo chksum %x stat %x",
chksum, stat);
if (stat) {
debugl1(cs, "FIFO CRC error");
dev_kfree_skb(skb, FREE_READ);
skb = NULL;
} else {
skb_queue_tail(&cs->rq, skb);
sched_event_D(cs, D_RCVBUFREADY);
}
}
} else
printk(KERN_WARNING "HFC: D receive out of memory\n");
sti();
WaitForBusy(cs);
cip = HFCD_FIFO | HFCD_F2_INC | HFCD_REC;
cli();
WaitNoBusy(cs);
stat = ReadReg(cs, HFCD_DATA, cip);
sti();
WaitForBusy(cs);
cip = HFCD_FIFO | HFCD_F2 | HFCD_REC;
cli();
WaitNoBusy(cs);
f2 = cs->readisac(cs, cip) & 0xf;
}
test_and_clear_bit(FLG_LOCK_ATOMIC, &cs->HW_Flags);
restore_flags(flags);
return(1);
}
static struct sk_buff
*hfc_empty_fifo(struct BCState *bcs, int count)
{
u_char *ptr;
struct sk_buff *skb;
struct IsdnCardState *cs = bcs->cs;
int idx;
int chksum;
long flags;
u_char stat, cip;
if ((cs->debug & L1_DEB_HSCX) && !(cs->debug & L1_DEB_HSCX_FIFO))
debugl1(cs, "hfc_empty_fifo");
idx = 0;
save_flags(flags);
if (count > HSCX_BUFMAX + 3) {
if (cs->debug & L1_DEB_WARN)
debugl1(cs, "hfc_empty_fifo: incoming packet too large");
cip = HFCB_FIFO | HFCB_FIFO_OUT | HFCB_REC | HFCB_CHANNEL(bcs->channel);
while (idx++ < count) {
cli();
WaitNoBusy(cs);
ReadReg(cs, HFCD_DATA_NODEB, cip);
sti();
}
skb = NULL;
} else if (count < 4) {
if (cs->debug & L1_DEB_WARN)
debugl1(cs, "hfc_empty_fifo: incoming packet too small");
cip = HFCB_FIFO | HFCB_FIFO_OUT | HFCB_REC | HFCB_CHANNEL(bcs->channel);
cli();
while ((idx++ < count) && WaitNoBusy(cs))
ReadReg(cs, HFCD_DATA_NODEB, cip);
skb = NULL;
} else if (!(skb = dev_alloc_skb(count - 3)))
printk(KERN_WARNING "HFC: receive out of memory\n");
else {
SET_SKB_FREE(skb);
ptr = skb_put(skb, count - 3);
idx = 0;
cip = HFCB_FIFO | HFCB_FIFO_OUT | HFCB_REC | HFCB_CHANNEL(bcs->channel);
cli();
while (idx < (count - 3)) {
cli();
if (!WaitNoBusy(cs))
break;
*ptr = ReadReg(cs, HFCD_DATA_NODEB, cip);
sti();
ptr++;
idx++;
}
if (idx != count - 3) {
sti();
debugl1(cs, "RFIFO BUSY error");
printk(KERN_WARNING "HFC FIFO channel %d BUSY Error\n", bcs->channel);
dev_kfree_skb(skb, FREE_READ);
skb = NULL;
} else {
cli();
WaitNoBusy(cs);
chksum = (ReadReg(cs, HFCD_DATA, cip) << 8);
WaitNoBusy(cs);
chksum += ReadReg(cs, HFCD_DATA, cip);
WaitNoBusy(cs);
stat = ReadReg(cs, HFCD_DATA, cip);
sti();
if (cs->debug & L1_DEB_HSCX)
debugl1(cs, "hfc_empty_fifo %d chksum %x stat %x",
bcs->channel, chksum, stat);
if (stat) {
debugl1(cs, "FIFO CRC error");
dev_kfree_skb(skb, FREE_READ);
skb = NULL;
}
}
}
sti();
WaitForBusy(cs);
cli();
WaitNoBusy(cs);
stat = ReadReg(cs, HFCD_DATA, HFCB_FIFO | HFCB_F2_INC |
HFCB_REC | HFCB_CHANNEL(bcs->channel));
sti();
WaitForBusy(cs);
restore_flags(flags);
return (skb);
}
void B1_handle_interrupt(avmb1_card * card)
{
unsigned char b1cmd;
struct sk_buff *skb;
unsigned ApplId;
unsigned MsgLen;
unsigned DataB3Len;
unsigned NCCI;
unsigned WindowSize;
if (!B1_rx_full(card->port))
return;
b1cmd = B1_get_byte(card->port);
switch (b1cmd) {
case RECEIVE_DATA_B3_IND:
ApplId = (unsigned) B1_get_word(card->port);
MsgLen = B1_get_slice(card->port, card->msgbuf);
DataB3Len = B1_get_slice(card->port, card->databuf);
if (showcapimsgs > 2) {
__u8 cmd = CAPIMSG_COMMAND(card->msgbuf);
__u8 subcmd = CAPIMSG_SUBCOMMAND(card->msgbuf);
__u32 contr = CAPIMSG_CONTROL(card->msgbuf);
CAPIMSG_SETDATA(card->msgbuf, card->databuf);
if (showcapimsgs & 1) {
printk(KERN_DEBUG "b1lli: Got [0x%lx] id#%d %s len=%u/%u\n",
(unsigned long) contr,
CAPIMSG_APPID(card->msgbuf),
capi_cmd2str(cmd, subcmd),
MsgLen, DataB3Len);
} else {
printk(KERN_DEBUG "b1lli: Got [0x%lx] %s\n", (unsigned long)contr, capi_message2str(card->msgbuf));
}
}
if (!(skb = dev_alloc_skb(DataB3Len + MsgLen))) {
printk(KERN_ERR "b1lli: incoming packet dropped\n");
} else {
SET_SKB_FREE(skb);
memcpy(skb_put(skb, MsgLen), card->msgbuf, MsgLen);
memcpy(skb_put(skb, DataB3Len), card->databuf, DataB3Len);
CAPIMSG_SETDATA(skb->data, skb->data + MsgLen);
avmb1_handle_capimsg(card, ApplId, skb);
}
break;
case RECEIVE_MESSAGE:
ApplId = (unsigned) B1_get_word(card->port);
MsgLen = B1_get_slice(card->port, card->msgbuf);
if (showcapimsgs) {
__u8 cmd = CAPIMSG_COMMAND(card->msgbuf);
__u8 subcmd = CAPIMSG_SUBCOMMAND(card->msgbuf);
__u32 contr = CAPIMSG_CONTROL(card->msgbuf);
if (showcapimsgs & 1) {
printk(KERN_DEBUG "b1lli: Got [0x%lx] id#%d %s len=%u\n",
(unsigned long) contr,
CAPIMSG_APPID(card->msgbuf),
capi_cmd2str(cmd, subcmd),
MsgLen);
} else {
printk(KERN_DEBUG "b1lli: Got [0x%lx] %s\n",
(unsigned long) contr,
capi_message2str(card->msgbuf));
}
}
if (!(skb = dev_alloc_skb(MsgLen))) {
printk(KERN_ERR "b1lli: incoming packet dropped\n");
} else {
SET_SKB_FREE(skb);
memcpy(skb_put(skb, MsgLen), card->msgbuf, MsgLen);
avmb1_handle_capimsg(card, ApplId, skb);
}
break;
case RECEIVE_NEW_NCCI:
ApplId = B1_get_word(card->port);
NCCI = B1_get_word(card->port);
WindowSize = B1_get_word(card->port);
if (showcapimsgs)
printk(KERN_DEBUG "b1lli: NEW_NCCI app %u ncci 0x%x\n", ApplId, NCCI);
avmb1_handle_new_ncci(card, ApplId, NCCI, WindowSize);
break;
case RECEIVE_FREE_NCCI:
ApplId = B1_get_word(card->port);
NCCI = B1_get_word(card->port);
if (showcapimsgs)
printk(KERN_DEBUG "b1lli: FREE_NCCI app %u ncci 0x%x\n", ApplId, NCCI);
avmb1_handle_free_ncci(card, ApplId, NCCI);
break;
case RECEIVE_START:
if (card->blocked)
printk(KERN_DEBUG "b1lli: RESTART\n");
card->blocked = 0;
break;
case RECEIVE_STOP:
printk(KERN_DEBUG "b1lli: STOP\n");
card->blocked = 1;
break;
case RECEIVE_INIT:
card->versionlen = B1_get_slice(card->port, card->versionbuf);
card->cardstate = CARD_ACTIVE;
parse_version(card);
printk(KERN_INFO "b1lli: %s-card (%s) with %s now active\n",
card->version[VER_CARDTYPE],
card->version[VER_DRIVER],
card->version[VER_PROTO]);
avmb1_card_ready(card);
break;
default:
printk(KERN_ERR "b1lli: B1_handle_interrupt: 0x%x ???\n", b1cmd);
break;
}
}
