617 lines
16 KiB
C
617 lines
16 KiB
C
/* $Id: isdn_v110.c,v 1.1.2.2 2004/01/12 22:37:19 keil Exp $
|
|
*
|
|
* Linux ISDN subsystem, V.110 related functions (linklevel).
|
|
*
|
|
* Copyright by Thomas Pfeiffer (pfeiffer@pds.de)
|
|
*
|
|
* This software may be used and distributed according to the terms
|
|
* of the GNU General Public License, incorporated herein by reference.
|
|
*
|
|
*/
|
|
|
|
#include <linux/string.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/delay.h>
|
|
|
|
#include <linux/isdn.h>
|
|
#include "isdn_v110.h"
|
|
|
|
#undef ISDN_V110_DEBUG
|
|
|
|
char *isdn_v110_revision = "$Revision: 1.1.2.2 $";
|
|
|
|
#define V110_38400 255
|
|
#define V110_19200 15
|
|
#define V110_9600 3
|
|
|
|
/*
|
|
* The following data are precoded matrices, online and offline matrix
|
|
* for 9600, 19200 und 38400, respectively
|
|
*/
|
|
static unsigned char V110_OnMatrix_9600[] =
|
|
{0xfc, 0xfc, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff,
|
|
0xff, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xfd,
|
|
0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff,
|
|
0xff, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xfd};
|
|
|
|
static unsigned char V110_OffMatrix_9600[] =
|
|
{0xfc, 0xfc, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
|
|
|
|
static unsigned char V110_OnMatrix_19200[] =
|
|
{0xf0, 0xf0, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7,
|
|
0xfd, 0xff, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7};
|
|
|
|
static unsigned char V110_OffMatrix_19200[] =
|
|
{0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
|
|
0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
|
|
|
|
static unsigned char V110_OnMatrix_38400[] =
|
|
{0x00, 0x7f, 0x7f, 0x7f, 0x7f, 0xfd, 0x7f, 0x7f, 0x7f, 0x7f};
|
|
|
|
static unsigned char V110_OffMatrix_38400[] =
|
|
{0x00, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff};
|
|
|
|
/*
|
|
* FlipBits reorders sequences of keylen bits in one byte.
|
|
* E.g. source order 7654321 will be converted to 45670123 when keylen = 4,
|
|
* and to 67452301 when keylen = 2. This is necessary because ordering on
|
|
* the isdn line is the other way.
|
|
*/
|
|
static inline unsigned char
|
|
FlipBits(unsigned char c, int keylen)
|
|
{
|
|
unsigned char b = c;
|
|
unsigned char bit = 128;
|
|
int i;
|
|
int j;
|
|
int hunks = (8 / keylen);
|
|
|
|
c = 0;
|
|
for (i = 0; i < hunks; i++) {
|
|
for (j = 0; j < keylen; j++) {
|
|
if (b & (bit >> j))
|
|
c |= bit >> (keylen - j - 1);
|
|
}
|
|
bit >>= keylen;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
|
|
/* isdn_v110_open allocates and initializes private V.110 data
|
|
* structures and returns a pointer to these.
|
|
*/
|
|
static isdn_v110_stream *
|
|
isdn_v110_open(unsigned char key, int hdrlen, int maxsize)
|
|
{
|
|
int i;
|
|
isdn_v110_stream *v;
|
|
|
|
if ((v = kzalloc(sizeof(isdn_v110_stream), GFP_ATOMIC)) == NULL)
|
|
return NULL;
|
|
v->key = key;
|
|
v->nbits = 0;
|
|
for (i = 0; key & (1 << i); i++)
|
|
v->nbits++;
|
|
|
|
v->nbytes = 8 / v->nbits;
|
|
v->decodelen = 0;
|
|
|
|
switch (key) {
|
|
case V110_38400:
|
|
v->OnlineFrame = V110_OnMatrix_38400;
|
|
v->OfflineFrame = V110_OffMatrix_38400;
|
|
break;
|
|
case V110_19200:
|
|
v->OnlineFrame = V110_OnMatrix_19200;
|
|
v->OfflineFrame = V110_OffMatrix_19200;
|
|
break;
|
|
default:
|
|
v->OnlineFrame = V110_OnMatrix_9600;
|
|
v->OfflineFrame = V110_OffMatrix_9600;
|
|
break;
|
|
}
|
|
v->framelen = v->nbytes * 10;
|
|
v->SyncInit = 5;
|
|
v->introducer = 0;
|
|
v->dbit = 1;
|
|
v->b = 0;
|
|
v->skbres = hdrlen;
|
|
v->maxsize = maxsize - hdrlen;
|
|
if ((v->encodebuf = kmalloc(maxsize, GFP_ATOMIC)) == NULL) {
|
|
kfree(v);
|
|
return NULL;
|
|
}
|
|
return v;
|
|
}
|
|
|
|
/* isdn_v110_close frees private V.110 data structures */
|
|
void
|
|
isdn_v110_close(isdn_v110_stream * v)
|
|
{
|
|
if (v == NULL)
|
|
return;
|
|
#ifdef ISDN_V110_DEBUG
|
|
printk(KERN_DEBUG "v110 close\n");
|
|
#endif
|
|
kfree(v->encodebuf);
|
|
kfree(v);
|
|
}
|
|
|
|
|
|
/*
|
|
* ValidHeaderBytes return the number of valid bytes in v->decodebuf
|
|
*/
|
|
static int
|
|
ValidHeaderBytes(isdn_v110_stream * v)
|
|
{
|
|
int i;
|
|
for (i = 0; (i < v->decodelen) && (i < v->nbytes); i++)
|
|
if ((v->decodebuf[i] & v->key) != 0)
|
|
break;
|
|
return i;
|
|
}
|
|
|
|
/*
|
|
* SyncHeader moves the decodebuf ptr to the next valid header
|
|
*/
|
|
static void
|
|
SyncHeader(isdn_v110_stream * v)
|
|
{
|
|
unsigned char *rbuf = v->decodebuf;
|
|
int len = v->decodelen;
|
|
|
|
if (len == 0)
|
|
return;
|
|
for (rbuf++, len--; len > 0; len--, rbuf++) /* such den SyncHeader in buf ! */
|
|
if ((*rbuf & v->key) == 0) /* erstes byte gefunden ? */
|
|
break; /* jupp! */
|
|
if (len)
|
|
memcpy(v->decodebuf, rbuf, len);
|
|
|
|
v->decodelen = len;
|
|
#ifdef ISDN_V110_DEBUG
|
|
printk(KERN_DEBUG "isdn_v110: Header resync\n");
|
|
#endif
|
|
}
|
|
|
|
/* DecodeMatrix takes n (n>=1) matrices (v110 frames, 10 bytes) where
|
|
len is the number of matrix-lines. len must be a multiple of 10, i.e.
|
|
only complete matices must be given.
|
|
From these, netto data is extracted and returned in buf. The return-value
|
|
is the bytecount of the decoded data.
|
|
*/
|
|
static int
|
|
DecodeMatrix(isdn_v110_stream * v, unsigned char *m, int len, unsigned char *buf)
|
|
{
|
|
int line = 0;
|
|
int buflen = 0;
|
|
int mbit = 64;
|
|
int introducer = v->introducer;
|
|
int dbit = v->dbit;
|
|
unsigned char b = v->b;
|
|
|
|
while (line < len) { /* Are we done with all lines of the matrix? */
|
|
if ((line % 10) == 0) { /* the 0. line of the matrix is always 0 ! */
|
|
if (m[line] != 0x00) { /* not 0 ? -> error! */
|
|
#ifdef ISDN_V110_DEBUG
|
|
printk(KERN_DEBUG "isdn_v110: DecodeMatrix, V110 Bad Header\n");
|
|
/* returning now is not the right thing, though :-( */
|
|
#endif
|
|
}
|
|
line++; /* next line of matrix */
|
|
continue;
|
|
} else if ((line % 10) == 5) { /* in line 5 there's only e-bits ! */
|
|
if ((m[line] & 0x70) != 0x30) { /* 011 has to be at the beginning! */
|
|
#ifdef ISDN_V110_DEBUG
|
|
printk(KERN_DEBUG "isdn_v110: DecodeMatrix, V110 Bad 5th line\n");
|
|
/* returning now is not the right thing, though :-( */
|
|
#endif
|
|
}
|
|
line++; /* next line */
|
|
continue;
|
|
} else if (!introducer) { /* every byte starts with 10 (stopbit, startbit) */
|
|
introducer = (m[line] & mbit) ? 0 : 1; /* current bit of the matrix */
|
|
next_byte:
|
|
if (mbit > 2) { /* was it the last bit in this line ? */
|
|
mbit >>= 1; /* no -> take next */
|
|
continue;
|
|
} /* otherwise start with leftmost bit in the next line */
|
|
mbit = 64;
|
|
line++;
|
|
continue;
|
|
} else { /* otherwise we need to set a data bit */
|
|
if (m[line] & mbit) /* was that bit set in the matrix ? */
|
|
b |= dbit; /* yes -> set it in the data byte */
|
|
else
|
|
b &= dbit - 1; /* no -> clear it in the data byte */
|
|
if (dbit < 128) /* is that data byte done ? */
|
|
dbit <<= 1; /* no, got the next bit */
|
|
else { /* data byte is done */
|
|
buf[buflen++] = b; /* copy byte into the output buffer */
|
|
introducer = b = 0; /* init of the intro sequence and of the data byte */
|
|
dbit = 1; /* next we look for the 0th bit */
|
|
}
|
|
goto next_byte; /* look for next bit in the matrix */
|
|
}
|
|
}
|
|
v->introducer = introducer;
|
|
v->dbit = dbit;
|
|
v->b = b;
|
|
return buflen; /* return number of bytes in the output buffer */
|
|
}
|
|
|
|
/*
|
|
* DecodeStream receives V.110 coded data from the input stream. It recovers the
|
|
* original frames.
|
|
* The input stream doesn't need to be framed
|
|
*/
|
|
struct sk_buff *
|
|
isdn_v110_decode(isdn_v110_stream * v, struct sk_buff *skb)
|
|
{
|
|
int i;
|
|
int j;
|
|
int len;
|
|
unsigned char *v110_buf;
|
|
unsigned char *rbuf;
|
|
|
|
if (!skb) {
|
|
printk(KERN_WARNING "isdn_v110_decode called with NULL skb!\n");
|
|
return NULL;
|
|
}
|
|
rbuf = skb->data;
|
|
len = skb->len;
|
|
if (v == NULL) {
|
|
/* invalid handle, no chance to proceed */
|
|
printk(KERN_WARNING "isdn_v110_decode called with NULL stream!\n");
|
|
dev_kfree_skb(skb);
|
|
return NULL;
|
|
}
|
|
if (v->decodelen == 0) /* cache empty? */
|
|
for (; len > 0; len--, rbuf++) /* scan for SyncHeader in buf */
|
|
if ((*rbuf & v->key) == 0)
|
|
break; /* found first byte */
|
|
if (len == 0) {
|
|
dev_kfree_skb(skb);
|
|
return NULL;
|
|
}
|
|
/* copy new data to decode-buffer */
|
|
memcpy(&(v->decodebuf[v->decodelen]), rbuf, len);
|
|
v->decodelen += len;
|
|
ReSync:
|
|
if (v->decodelen < v->nbytes) { /* got a new header ? */
|
|
dev_kfree_skb(skb);
|
|
return NULL; /* no, try later */
|
|
}
|
|
if (ValidHeaderBytes(v) != v->nbytes) { /* is that a valid header? */
|
|
SyncHeader(v); /* no -> look for header */
|
|
goto ReSync;
|
|
}
|
|
len = (v->decodelen - (v->decodelen % (10 * v->nbytes))) / v->nbytes;
|
|
if ((v110_buf = kmalloc(len, GFP_ATOMIC)) == NULL) {
|
|
printk(KERN_WARNING "isdn_v110_decode: Couldn't allocate v110_buf\n");
|
|
dev_kfree_skb(skb);
|
|
return NULL;
|
|
}
|
|
for (i = 0; i < len; i++) {
|
|
v110_buf[i] = 0;
|
|
for (j = 0; j < v->nbytes; j++)
|
|
v110_buf[i] |= (v->decodebuf[(i * v->nbytes) + j] & v->key) << (8 - ((j + 1) * v->nbits));
|
|
v110_buf[i] = FlipBits(v110_buf[i], v->nbits);
|
|
}
|
|
v->decodelen = (v->decodelen % (10 * v->nbytes));
|
|
memcpy(v->decodebuf, &(v->decodebuf[len * v->nbytes]), v->decodelen);
|
|
|
|
skb_trim(skb, DecodeMatrix(v, v110_buf, len, skb->data));
|
|
kfree(v110_buf);
|
|
if (skb->len)
|
|
return skb;
|
|
else {
|
|
kfree_skb(skb);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
/* EncodeMatrix takes input data in buf, len is the bytecount.
|
|
Data is encoded into v110 frames in m. Return value is the number of
|
|
matrix-lines generated.
|
|
*/
|
|
static int
|
|
EncodeMatrix(unsigned char *buf, int len, unsigned char *m, int mlen)
|
|
{
|
|
int line = 0;
|
|
int i = 0;
|
|
int mbit = 128;
|
|
int dbit = 1;
|
|
int introducer = 3;
|
|
int ibit[] = {0, 1, 1};
|
|
|
|
while ((i < len) && (line < mlen)) { /* while we still have input data */
|
|
switch (line % 10) { /* in which line of the matrix are we? */
|
|
case 0:
|
|
m[line++] = 0x00; /* line 0 is always 0 */
|
|
mbit = 128; /* go on with the 7th bit */
|
|
break;
|
|
case 5:
|
|
m[line++] = 0xbf; /* line 5 is always 10111111 */
|
|
mbit = 128; /* go on with the 7th bit */
|
|
break;
|
|
}
|
|
if (line >= mlen) {
|
|
printk(KERN_WARNING "isdn_v110 (EncodeMatrix): buffer full!\n");
|
|
return line;
|
|
}
|
|
next_bit:
|
|
switch (mbit) { /* leftmost or rightmost bit ? */
|
|
case 1:
|
|
line++; /* rightmost -> go to next line */
|
|
if (line >= mlen) {
|
|
printk(KERN_WARNING "isdn_v110 (EncodeMatrix): buffer full!\n");
|
|
return line;
|
|
}
|
|
case 128:
|
|
m[line] = 128; /* leftmost -> set byte to 1000000 */
|
|
mbit = 64; /* current bit in the matrix line */
|
|
continue;
|
|
}
|
|
if (introducer) { /* set 110 sequence ? */
|
|
introducer--; /* set on digit less */
|
|
m[line] |= ibit[introducer] ? mbit : 0; /* set corresponding bit */
|
|
mbit >>= 1; /* bit of matrix line >> 1 */
|
|
goto next_bit; /* and go on there */
|
|
} /* else push data bits into the matrix! */
|
|
m[line] |= (buf[i] & dbit) ? mbit : 0; /* set data bit in matrix */
|
|
if (dbit == 128) { /* was it the last one? */
|
|
dbit = 1; /* then go on with first bit of */
|
|
i++; /* next byte in input buffer */
|
|
if (i < len) /* input buffer done ? */
|
|
introducer = 3; /* no, write introducer 110 */
|
|
else { /* input buffer done ! */
|
|
m[line] |= (mbit - 1) & 0xfe; /* set remaining bits in line to 1 */
|
|
break;
|
|
}
|
|
} else /* not the last data bit */
|
|
dbit <<= 1; /* then go to next data bit */
|
|
mbit >>= 1; /* go to next bit of matrix */
|
|
goto next_bit;
|
|
|
|
}
|
|
/* if necessary, generate remaining lines of the matrix... */
|
|
if ((line) && ((line + 10) < mlen))
|
|
switch (++line % 10) {
|
|
case 1:
|
|
m[line++] = 0xfe;
|
|
case 2:
|
|
m[line++] = 0xfe;
|
|
case 3:
|
|
m[line++] = 0xfe;
|
|
case 4:
|
|
m[line++] = 0xfe;
|
|
case 5:
|
|
m[line++] = 0xbf;
|
|
case 6:
|
|
m[line++] = 0xfe;
|
|
case 7:
|
|
m[line++] = 0xfe;
|
|
case 8:
|
|
m[line++] = 0xfe;
|
|
case 9:
|
|
m[line++] = 0xfe;
|
|
}
|
|
return line; /* that's how many lines we have */
|
|
}
|
|
|
|
/*
|
|
* Build a sync frame.
|
|
*/
|
|
static struct sk_buff *
|
|
isdn_v110_sync(isdn_v110_stream *v)
|
|
{
|
|
struct sk_buff *skb;
|
|
|
|
if (v == NULL) {
|
|
/* invalid handle, no chance to proceed */
|
|
printk(KERN_WARNING "isdn_v110_sync called with NULL stream!\n");
|
|
return NULL;
|
|
}
|
|
if ((skb = dev_alloc_skb(v->framelen + v->skbres))) {
|
|
skb_reserve(skb, v->skbres);
|
|
memcpy(skb_put(skb, v->framelen), v->OfflineFrame, v->framelen);
|
|
}
|
|
return skb;
|
|
}
|
|
|
|
/*
|
|
* Build an idle frame.
|
|
*/
|
|
static struct sk_buff *
|
|
isdn_v110_idle(isdn_v110_stream *v)
|
|
{
|
|
struct sk_buff *skb;
|
|
|
|
if (v == NULL) {
|
|
/* invalid handle, no chance to proceed */
|
|
printk(KERN_WARNING "isdn_v110_sync called with NULL stream!\n");
|
|
return NULL;
|
|
}
|
|
if ((skb = dev_alloc_skb(v->framelen + v->skbres))) {
|
|
skb_reserve(skb, v->skbres);
|
|
memcpy(skb_put(skb, v->framelen), v->OnlineFrame, v->framelen);
|
|
}
|
|
return skb;
|
|
}
|
|
|
|
struct sk_buff *
|
|
isdn_v110_encode(isdn_v110_stream * v, struct sk_buff *skb)
|
|
{
|
|
int i;
|
|
int j;
|
|
int rlen;
|
|
int mlen;
|
|
int olen;
|
|
int size;
|
|
int sval1;
|
|
int sval2;
|
|
int nframes;
|
|
unsigned char *v110buf;
|
|
unsigned char *rbuf;
|
|
struct sk_buff *nskb;
|
|
|
|
if (v == NULL) {
|
|
/* invalid handle, no chance to proceed */
|
|
printk(KERN_WARNING "isdn_v110_encode called with NULL stream!\n");
|
|
return NULL;
|
|
}
|
|
if (!skb) {
|
|
/* invalid skb, no chance to proceed */
|
|
printk(KERN_WARNING "isdn_v110_encode called with NULL skb!\n");
|
|
return NULL;
|
|
}
|
|
rlen = skb->len;
|
|
nframes = (rlen + 3) / 4;
|
|
v110buf = v->encodebuf;
|
|
if ((nframes * 40) > v->maxsize) {
|
|
size = v->maxsize;
|
|
rlen = v->maxsize / 40;
|
|
} else
|
|
size = nframes * 40;
|
|
if (!(nskb = dev_alloc_skb(size + v->skbres + sizeof(int)))) {
|
|
printk(KERN_WARNING "isdn_v110_encode: Couldn't alloc skb\n");
|
|
return NULL;
|
|
}
|
|
skb_reserve(nskb, v->skbres + sizeof(int));
|
|
if (skb->len == 0) {
|
|
memcpy(skb_put(nskb, v->framelen), v->OnlineFrame, v->framelen);
|
|
*((int *)skb_push(nskb, sizeof(int))) = 0;
|
|
return nskb;
|
|
}
|
|
mlen = EncodeMatrix(skb->data, rlen, v110buf, size);
|
|
/* now distribute 2 or 4 bits each to the output stream! */
|
|
rbuf = skb_put(nskb, size);
|
|
olen = 0;
|
|
sval1 = 8 - v->nbits;
|
|
sval2 = v->key << sval1;
|
|
for (i = 0; i < mlen; i++) {
|
|
v110buf[i] = FlipBits(v110buf[i], v->nbits);
|
|
for (j = 0; j < v->nbytes; j++) {
|
|
if (size--)
|
|
*rbuf++ = ~v->key | (((v110buf[i] << (j * v->nbits)) & sval2) >> sval1);
|
|
else {
|
|
printk(KERN_WARNING "isdn_v110_encode: buffers full!\n");
|
|
goto buffer_full;
|
|
}
|
|
olen++;
|
|
}
|
|
}
|
|
buffer_full:
|
|
skb_trim(nskb, olen);
|
|
*((int *)skb_push(nskb, sizeof(int))) = rlen;
|
|
return nskb;
|
|
}
|
|
|
|
int
|
|
isdn_v110_stat_callback(int idx, isdn_ctrl *c)
|
|
{
|
|
isdn_v110_stream *v = NULL;
|
|
int i;
|
|
int ret = 0;
|
|
|
|
if (idx < 0)
|
|
return 0;
|
|
switch (c->command) {
|
|
case ISDN_STAT_BSENT:
|
|
/* Keep the send-queue of the driver filled
|
|
* with frames:
|
|
* If number of outstanding frames < 3,
|
|
* send down an Idle-Frame (or an Sync-Frame, if
|
|
* v->SyncInit != 0).
|
|
*/
|
|
if (!(v = dev->v110[idx]))
|
|
return 0;
|
|
atomic_inc(&dev->v110use[idx]);
|
|
for (i=0; i * v->framelen < c->parm.length; i++) {
|
|
if (v->skbidle > 0) {
|
|
v->skbidle--;
|
|
ret = 1;
|
|
} else {
|
|
if (v->skbuser > 0)
|
|
v->skbuser--;
|
|
ret = 0;
|
|
}
|
|
}
|
|
for (i = v->skbuser + v->skbidle; i < 2; i++) {
|
|
struct sk_buff *skb;
|
|
if (v->SyncInit > 0)
|
|
skb = isdn_v110_sync(v);
|
|
else
|
|
skb = isdn_v110_idle(v);
|
|
if (skb) {
|
|
if (dev->drv[c->driver]->interface->writebuf_skb(c->driver, c->arg, 1, skb) <= 0) {
|
|
dev_kfree_skb(skb);
|
|
break;
|
|
} else {
|
|
if (v->SyncInit)
|
|
v->SyncInit--;
|
|
v->skbidle++;
|
|
}
|
|
} else
|
|
break;
|
|
}
|
|
atomic_dec(&dev->v110use[idx]);
|
|
return ret;
|
|
case ISDN_STAT_DHUP:
|
|
case ISDN_STAT_BHUP:
|
|
while (1) {
|
|
atomic_inc(&dev->v110use[idx]);
|
|
if (atomic_dec_and_test(&dev->v110use[idx])) {
|
|
isdn_v110_close(dev->v110[idx]);
|
|
dev->v110[idx] = NULL;
|
|
break;
|
|
}
|
|
mdelay(1);
|
|
}
|
|
break;
|
|
case ISDN_STAT_BCONN:
|
|
if (dev->v110emu[idx] && (dev->v110[idx] == NULL)) {
|
|
int hdrlen = dev->drv[c->driver]->interface->hl_hdrlen;
|
|
int maxsize = dev->drv[c->driver]->interface->maxbufsize;
|
|
atomic_inc(&dev->v110use[idx]);
|
|
switch (dev->v110emu[idx]) {
|
|
case ISDN_PROTO_L2_V11096:
|
|
dev->v110[idx] = isdn_v110_open(V110_9600, hdrlen, maxsize);
|
|
break;
|
|
case ISDN_PROTO_L2_V11019:
|
|
dev->v110[idx] = isdn_v110_open(V110_19200, hdrlen, maxsize);
|
|
break;
|
|
case ISDN_PROTO_L2_V11038:
|
|
dev->v110[idx] = isdn_v110_open(V110_38400, hdrlen, maxsize);
|
|
break;
|
|
default:;
|
|
}
|
|
if ((v = dev->v110[idx])) {
|
|
while (v->SyncInit) {
|
|
struct sk_buff *skb = isdn_v110_sync(v);
|
|
if (dev->drv[c->driver]->interface->writebuf_skb(c->driver, c->arg, 1, skb) <= 0) {
|
|
dev_kfree_skb(skb);
|
|
/* Unable to send, try later */
|
|
break;
|
|
}
|
|
v->SyncInit--;
|
|
v->skbidle++;
|
|
}
|
|
} else
|
|
printk(KERN_WARNING "isdn_v110: Couldn't open stream for chan %d\n", idx);
|
|
atomic_dec(&dev->v110use[idx]);
|
|
}
|
|
break;
|
|
default:
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|