drivers/isdn/i4l/isdn_v110.c - kernel/msm-4.9 - Gitiles

 /* $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;
 }
	/* $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;
	}