patch-2.3.99-pre3 linux/drivers/isdn/isdn_v110.c

• Lines: 294
• Date: Thu Mar 23 08:38:57 2000
• Orig file: v2.3.99-pre2/linux/drivers/isdn/isdn_v110.c
• Orig date: Thu Nov 11 20:11:39 1999

diff -u --recursive --new-file v2.3.99-pre2/linux/drivers/isdn/isdn_v110.c linux/drivers/isdn/isdn_v110.c
@@ -1,4 +1,4 @@
-/* $Id: isdn_v110.c,v 1.3 1999/10/30 09:49:28 keil Exp $
+/* $Id: isdn_v110.c,v 1.4 2000/03/16 16:34:12 kai Exp $
 
  * Linux ISDN subsystem, V.110 related functions (linklevel).
  *
@@ -19,6 +19,11 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * $Log: isdn_v110.c,v $
+ * Revision 1.4  2000/03/16 16:34:12  kai
+ * some translation work
+ *
+ * there shouldn't be any German comments lurking around anymore ;-)
+ *
  * Revision 1.3  1999/10/30 09:49:28  keil
  * Reinit of v110 structs
  *
@@ -39,14 +44,15 @@
 
 #undef ISDN_V110_DEBUG
 
-char *isdn_v110_revision = "$Revision: 1.3 $";
+char *isdn_v110_revision = "$Revision: 1.4 $";
 
 #define V110_38400 255
 #define V110_19200  15
 #define V110_9600    3
 
-/* Die folgenden Daten sind fertig kodierte Matrizen, jeweils
-   als online und offline matrix für 9600, 19200 und 38400
+/* 
+ * 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,
@@ -74,13 +80,12 @@
 static unsigned char V110_OffMatrix_38400[] =
 {0x00, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff};
 
-
-/* FlipBits dreht die Reihenfolge von jeweils keylen bits in einem byte um.
-   Aus der Bitreihenfolge 76543210 werden bei keylen=4 die bits 45670123,
-   bei keylen=2 die bits 67452301. Dies ist notwendig, weil die reihenfolge
-   auf der isdn-leitung falsch herum ist.
+/* 
+ * 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 the other way.
  */
-
 static __inline unsigned char
 FlipBits(unsigned char c, int keylen)
 {
@@ -164,8 +169,9 @@
 }
 
 
-/* ValidHeaderBytes prüft, wieviele bytes in v->decodebuf gültig sind */
-
+/* 
+ * ValidHeaderBytes return the number of valid bytes in v->decodebuf 
+ */
 static int
 ValidHeaderBytes(isdn_v110_stream * v)
 {
@@ -176,8 +182,9 @@
 	return i;
 }
 
-/* SyncHeader schiebt den decodebuf pointer auf den nächsten gültigen header */
-
+/* 
+ * SyncHeader moves the decodebuf ptr to the next valid header 
+ */
 static void
 SyncHeader(isdn_v110_stream * v)
 {
@@ -214,68 +221,60 @@
 	int dbit = v->dbit;
 	unsigned char b = v->b;
 
-	while (line < len) {    /* sind schon alle matrizenzeilen abgearbeitet? */
-		if ((line % 10) == 0) {	/* die 0. zeile der matrix ist immer null ! */
-			if (m[line] != 0x00) {	/* nicht 0 ? dann fehler! */
+	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
-
-/*
-  dann einen return zu machen, ist auch irgendwie nicht das richtige! :-(
-  v->introducer = 0; v->dbit = 1; v->b = 0;
-  return buflen;                                                                                                     anzahl schon erzeugter daten zurückgeben!
-  */
-			}
-			line++; /* sonst die nächste matrixzeile nehmen */
+			} 
+			line++; /* next line of matrix */
 			continue;
-		} else if ((line % 10) == 5) {	/* in zeile 5 stehen nur e-bits ! */
-			if ((m[line] & 0x70) != 0x30) {	/* 011 muß am anfang stehen! */
+		} 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
-/* dann einen return zu machen, ist auch irgendwie nicht das richtige! :-(
-   v->introducer = 0; v->dbit = 1; v->b = 0;
-   return buflen;
- */
 			}
-			line++; /* alles klar, nächste zeile */
+			line++; /* next line */
 			continue;
 		} else if (!introducer) {	/* every byte starts with 10 (stopbit, startbit) */
-			introducer = (m[line] & mbit) ? 0 : 1;	/* aktuelles bit der matrix */
+			introducer = (m[line] & mbit) ? 0 : 1;	/* current bit of the matrix */
 		      next_byte:
-			if (mbit > 2) {	/* war es das letzte bit dieser matrixzeile ? */
-				mbit >>= 1;	/* nein, nimm das nächste in dieser zeile */
+			if (mbit > 2) {	/* was it the last bit in this line ? */
+				mbit >>= 1;	/* no -> take next */
 				continue;
-			}       /* sonst links in der nächsten zeile anfangen */
+			}       /* otherwise start with leftmost bit in the next line */
 			mbit = 64;
 			line++;
 			continue;
-		} else {        /* sonst müssen wir ein datenbit setzen */
-			if (m[line] & mbit)	/* war das bit in der matrix gesetzt ? */
-				b |= dbit;	/* ja, dann setz es auch im datenbyte  */
+		} 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;	/* nein, lösch bit im datenbyte */
-			if (dbit < 128)	/* haben wir schon ein ganzes byte voll ? */
-				dbit <<= 1;	/* nein, auf zum nächsten datenbit */
-			else {  /* ein ganzes datenbyte ist voll */
-				buf[buflen++] = b;	/* byte in den output buffer kopieren */
-				introducer = b = 0;	/* Init der Introsequenz und des datenbytes */
-				dbit = 1;	/* als nächstes suchen wir das nullte bit */
+				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;	/* suche das nächste bit in der matrix */
+			goto next_byte;	/* look for next bit in the matrix */
 		}
 	}
 	v->introducer = introducer;
 	v->dbit = dbit;
 	v->b = b;
-	return buflen;          /* return anzahl der bytes im output buffer */
+	return buflen;          /* return number of bytes in the output buffer */
 }
 
-/* DecodeStream erhält vom input stream V110 kodierte Daten, die zu den
-   V110 frames zusammengepackt werden müssen. Die Daten können an diese
-   Schnittstelle so übergeben werden, wie sie von der Leitung kommen, ohne
-   darauf achten zu müssen, das frames usw. eingehalten werden.
+/* 
+ * 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)
@@ -314,8 +313,8 @@
 		dev_kfree_skb(skb);
 		return NULL;    /* no, try later      */
 	}
-	if (ValidHeaderBytes(v) != v->nbytes) {	/* ist es ein ungültiger header ? */
-		SyncHeader(v);  /* nein, such einen header */
+	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;
@@ -357,15 +356,15 @@
 	int introducer = 3;
 	int ibit[] = {0, 1, 1};
 
-	while ((i < len) && (line < mlen)) {	/* solange noch input da ist */
-		switch (line % 10) {	/* in welcher matrixzeile sind wir ? */
+	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;	/* zeile 0 ist immer 0 */
-				mbit = 128;	/* und es geht mit dem 7. bit weiter */
+				m[line++] = 0x00;	/* line 0 is always 0 */
+				mbit = 128;	/* go on with the 7th bit */
 				break;
 			case 5:
-				m[line++] = 0xbf;	/* zeile 5 ist immer 10111111 */
-				mbit = 128;	/* und es geht mit dem 7. bit weiter */
+				m[line++] = 0xbf;	/* line 5 is always 10111111 */
+				mbit = 128;	/* go on with the 7th bit */
 				break;
 		}
 		if (line >= mlen) {
@@ -373,41 +372,41 @@
 			return line;
 		}
 	next_bit:
-		switch (mbit) { /* ganz linkes oder rechtes bit ? */
+		switch (mbit) { /* leftmost or rightmost bit ? */
 			case 1:
-				line++;	/* ganz rechts ! dann in die nächste */
+				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;	/* ganz links byte auf 1000000 setzen */
-				mbit = 64;	/* aktuelles bit in der matrixzeile */
+				m[line] = 128;	/* leftmost -> set byte to 1000000 */
+				mbit = 64;	/* current bit in the matrix line */
 				continue;
 		}
-		if (introducer) {	/* 110 sequenz setzen ? */
-			introducer--;	/* ein digit weniger setzen */
-			m[line] |= ibit[introducer] ? mbit : 0;	/* entsprechendes bit setzen */
-			mbit >>= 1;	/* bit der matrixzeile >> 1 */
-			goto next_bit;	/* und dort weiter machen */
-		}               /* else datenbits in die matrix packen! */
-		m[line] |= (buf[i] & dbit) ? mbit : 0;	/* datenbit in matrix setzen */
-		if (dbit == 128) {	/* war es das letzte datenbit ? */
-			dbit = 1;	/* dann mach beim nächsten weiter */
-			i++;    /* nächste datenbyte des input buffers */
-			if (i < len)	/* war es schon das letzte ? */
-				introducer = 3;	/* nein, schreib den introducer 110 */
-			else {  /* war das letzte datenbyte ! */
-				m[line] |= (mbit - 1) & 0xfe;	/* setz restliche bits der zeile auf 1 */
+		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          /* nicht das letzte datenbit */
-			dbit <<= 1;	/* dann gehe zum nächsten datenbit */
-		mbit >>= 1;     /* und setz bit der matrix weiter */
+		} 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;
 
 	}
-	/* evtl. noch restliche zeilen in der matrix generieren... */
+	/* if necessary, generate remaining lines of the matrix... */
 	if ((line) && ((line + 10) < mlen))
 		switch (++line % 10) {
 			case 1:
@@ -429,7 +428,7 @@
 			case 9:
 				m[line++] = 0xfe;
 		}
-	return line;            /* soviele matrixzeilen sind es */
+	return line;            /* that's how many lines we have */
 }
 
 /*
@@ -517,7 +516,7 @@
 		return nskb;
 	}
 	mlen = EncodeMatrix(skb->data, rlen, v110buf, size);
-	/* jetzt noch jeweils 2 oder 4 bits auf den output stream verteilen! */
+	/* now distribute 2 or 4 bits each to the output stream! */
 	rbuf = skb_put(nskb, size);
 	olen = 0;
 	sval1 = 8 - v->nbits;