Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* $Id: isdn_v110.c,v 1.1.2.2 2004/01/12 22:37:19 keil Exp $ |
2 | * | |
3 | * Linux ISDN subsystem, V.110 related functions (linklevel). | |
4 | * | |
5 | * Copyright by Thomas Pfeiffer (pfeiffer@pds.de) | |
6 | * | |
7 | * This software may be used and distributed according to the terms | |
8 | * of the GNU General Public License, incorporated herein by reference. | |
9 | * | |
10 | */ | |
11 | ||
12 | #include <linux/string.h> | |
13 | #include <linux/kernel.h> | |
14 | #include <linux/slab.h> | |
15 | #include <linux/mm.h> | |
16 | #include <linux/delay.h> | |
17 | ||
18 | #include <linux/isdn.h> | |
19 | #include "isdn_v110.h" | |
20 | ||
21 | #undef ISDN_V110_DEBUG | |
22 | ||
23 | char *isdn_v110_revision = "$Revision: 1.1.2.2 $"; | |
24 | ||
25 | #define V110_38400 255 | |
26 | #define V110_19200 15 | |
27 | #define V110_9600 3 | |
28 | ||
475be4d8 JP |
29 | /* |
30 | * The following data are precoded matrices, online and offline matrix | |
1da177e4 LT |
31 | * for 9600, 19200 und 38400, respectively |
32 | */ | |
33 | static unsigned char V110_OnMatrix_9600[] = | |
34 | {0xfc, 0xfc, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, | |
35 | 0xff, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xfd, | |
36 | 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, | |
37 | 0xff, 0xfd, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xfd}; | |
38 | ||
39 | static unsigned char V110_OffMatrix_9600[] = | |
40 | {0xfc, 0xfc, 0xfc, 0xfc, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, | |
41 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, | |
42 | 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, | |
43 | 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; | |
44 | ||
45 | static unsigned char V110_OnMatrix_19200[] = | |
46 | {0xf0, 0xf0, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7, | |
47 | 0xfd, 0xff, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7, 0xff, 0xf7}; | |
48 | ||
49 | static unsigned char V110_OffMatrix_19200[] = | |
50 | {0xf0, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, | |
51 | 0xfd, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff}; | |
52 | ||
53 | static unsigned char V110_OnMatrix_38400[] = | |
54 | {0x00, 0x7f, 0x7f, 0x7f, 0x7f, 0xfd, 0x7f, 0x7f, 0x7f, 0x7f}; | |
55 | ||
56 | static unsigned char V110_OffMatrix_38400[] = | |
57 | {0x00, 0xff, 0xff, 0xff, 0xff, 0xfd, 0xff, 0xff, 0xff, 0xff}; | |
58 | ||
475be4d8 | 59 | /* |
1da177e4 LT |
60 | * FlipBits reorders sequences of keylen bits in one byte. |
61 | * E.g. source order 7654321 will be converted to 45670123 when keylen = 4, | |
62 | * and to 67452301 when keylen = 2. This is necessary because ordering on | |
63 | * the isdn line is the other way. | |
64 | */ | |
d4f77514 | 65 | static inline unsigned char |
1da177e4 LT |
66 | FlipBits(unsigned char c, int keylen) |
67 | { | |
68 | unsigned char b = c; | |
69 | unsigned char bit = 128; | |
70 | int i; | |
71 | int j; | |
72 | int hunks = (8 / keylen); | |
73 | ||
74 | c = 0; | |
75 | for (i = 0; i < hunks; i++) { | |
76 | for (j = 0; j < keylen; j++) { | |
77 | if (b & (bit >> j)) | |
78 | c |= bit >> (keylen - j - 1); | |
79 | } | |
80 | bit >>= keylen; | |
81 | } | |
82 | return c; | |
83 | } | |
84 | ||
85 | ||
86 | /* isdn_v110_open allocates and initializes private V.110 data | |
87 | * structures and returns a pointer to these. | |
88 | */ | |
89 | static isdn_v110_stream * | |
90 | isdn_v110_open(unsigned char key, int hdrlen, int maxsize) | |
91 | { | |
92 | int i; | |
93 | isdn_v110_stream *v; | |
94 | ||
41f96935 | 95 | if ((v = kzalloc(sizeof(isdn_v110_stream), GFP_ATOMIC)) == NULL) |
1da177e4 | 96 | return NULL; |
1da177e4 LT |
97 | v->key = key; |
98 | v->nbits = 0; | |
99 | for (i = 0; key & (1 << i); i++) | |
100 | v->nbits++; | |
101 | ||
102 | v->nbytes = 8 / v->nbits; | |
103 | v->decodelen = 0; | |
104 | ||
105 | switch (key) { | |
475be4d8 JP |
106 | case V110_38400: |
107 | v->OnlineFrame = V110_OnMatrix_38400; | |
108 | v->OfflineFrame = V110_OffMatrix_38400; | |
109 | break; | |
110 | case V110_19200: | |
111 | v->OnlineFrame = V110_OnMatrix_19200; | |
112 | v->OfflineFrame = V110_OffMatrix_19200; | |
113 | break; | |
114 | default: | |
115 | v->OnlineFrame = V110_OnMatrix_9600; | |
116 | v->OfflineFrame = V110_OffMatrix_9600; | |
117 | break; | |
1da177e4 LT |
118 | } |
119 | v->framelen = v->nbytes * 10; | |
120 | v->SyncInit = 5; | |
121 | v->introducer = 0; | |
122 | v->dbit = 1; | |
123 | v->b = 0; | |
124 | v->skbres = hdrlen; | |
125 | v->maxsize = maxsize - hdrlen; | |
126 | if ((v->encodebuf = kmalloc(maxsize, GFP_ATOMIC)) == NULL) { | |
127 | kfree(v); | |
128 | return NULL; | |
129 | } | |
130 | return v; | |
131 | } | |
132 | ||
133 | /* isdn_v110_close frees private V.110 data structures */ | |
134 | void | |
475be4d8 | 135 | isdn_v110_close(isdn_v110_stream *v) |
1da177e4 LT |
136 | { |
137 | if (v == NULL) | |
138 | return; | |
139 | #ifdef ISDN_V110_DEBUG | |
140 | printk(KERN_DEBUG "v110 close\n"); | |
141 | #endif | |
142 | kfree(v->encodebuf); | |
143 | kfree(v); | |
144 | } | |
145 | ||
146 | ||
475be4d8 JP |
147 | /* |
148 | * ValidHeaderBytes return the number of valid bytes in v->decodebuf | |
1da177e4 LT |
149 | */ |
150 | static int | |
475be4d8 | 151 | ValidHeaderBytes(isdn_v110_stream *v) |
1da177e4 LT |
152 | { |
153 | int i; | |
154 | for (i = 0; (i < v->decodelen) && (i < v->nbytes); i++) | |
155 | if ((v->decodebuf[i] & v->key) != 0) | |
156 | break; | |
157 | return i; | |
158 | } | |
159 | ||
475be4d8 JP |
160 | /* |
161 | * SyncHeader moves the decodebuf ptr to the next valid header | |
1da177e4 LT |
162 | */ |
163 | static void | |
475be4d8 | 164 | SyncHeader(isdn_v110_stream *v) |
1da177e4 LT |
165 | { |
166 | unsigned char *rbuf = v->decodebuf; | |
167 | int len = v->decodelen; | |
168 | ||
169 | if (len == 0) | |
170 | return; | |
171 | for (rbuf++, len--; len > 0; len--, rbuf++) /* such den SyncHeader in buf ! */ | |
172 | if ((*rbuf & v->key) == 0) /* erstes byte gefunden ? */ | |
173 | break; /* jupp! */ | |
174 | if (len) | |
175 | memcpy(v->decodebuf, rbuf, len); | |
176 | ||
177 | v->decodelen = len; | |
178 | #ifdef ISDN_V110_DEBUG | |
179 | printk(KERN_DEBUG "isdn_v110: Header resync\n"); | |
180 | #endif | |
181 | } | |
182 | ||
183 | /* DecodeMatrix takes n (n>=1) matrices (v110 frames, 10 bytes) where | |
184 | len is the number of matrix-lines. len must be a multiple of 10, i.e. | |
185 | only complete matices must be given. | |
186 | From these, netto data is extracted and returned in buf. The return-value | |
187 | is the bytecount of the decoded data. | |
475be4d8 | 188 | */ |
1da177e4 | 189 | static int |
475be4d8 | 190 | DecodeMatrix(isdn_v110_stream *v, unsigned char *m, int len, unsigned char *buf) |
1da177e4 LT |
191 | { |
192 | int line = 0; | |
193 | int buflen = 0; | |
194 | int mbit = 64; | |
195 | int introducer = v->introducer; | |
196 | int dbit = v->dbit; | |
197 | unsigned char b = v->b; | |
198 | ||
199 | while (line < len) { /* Are we done with all lines of the matrix? */ | |
200 | if ((line % 10) == 0) { /* the 0. line of the matrix is always 0 ! */ | |
201 | if (m[line] != 0x00) { /* not 0 ? -> error! */ | |
202 | #ifdef ISDN_V110_DEBUG | |
203 | printk(KERN_DEBUG "isdn_v110: DecodeMatrix, V110 Bad Header\n"); | |
204 | /* returning now is not the right thing, though :-( */ | |
205 | #endif | |
475be4d8 | 206 | } |
1da177e4 LT |
207 | line++; /* next line of matrix */ |
208 | continue; | |
209 | } else if ((line % 10) == 5) { /* in line 5 there's only e-bits ! */ | |
210 | if ((m[line] & 0x70) != 0x30) { /* 011 has to be at the beginning! */ | |
211 | #ifdef ISDN_V110_DEBUG | |
212 | printk(KERN_DEBUG "isdn_v110: DecodeMatrix, V110 Bad 5th line\n"); | |
213 | /* returning now is not the right thing, though :-( */ | |
214 | #endif | |
215 | } | |
216 | line++; /* next line */ | |
217 | continue; | |
218 | } else if (!introducer) { /* every byte starts with 10 (stopbit, startbit) */ | |
219 | introducer = (m[line] & mbit) ? 0 : 1; /* current bit of the matrix */ | |
475be4d8 | 220 | next_byte: |
1da177e4 LT |
221 | if (mbit > 2) { /* was it the last bit in this line ? */ |
222 | mbit >>= 1; /* no -> take next */ | |
223 | continue; | |
224 | } /* otherwise start with leftmost bit in the next line */ | |
225 | mbit = 64; | |
226 | line++; | |
227 | continue; | |
228 | } else { /* otherwise we need to set a data bit */ | |
229 | if (m[line] & mbit) /* was that bit set in the matrix ? */ | |
230 | b |= dbit; /* yes -> set it in the data byte */ | |
231 | else | |
232 | b &= dbit - 1; /* no -> clear it in the data byte */ | |
233 | if (dbit < 128) /* is that data byte done ? */ | |
234 | dbit <<= 1; /* no, got the next bit */ | |
235 | else { /* data byte is done */ | |
236 | buf[buflen++] = b; /* copy byte into the output buffer */ | |
237 | introducer = b = 0; /* init of the intro sequence and of the data byte */ | |
238 | dbit = 1; /* next we look for the 0th bit */ | |
239 | } | |
240 | goto next_byte; /* look for next bit in the matrix */ | |
241 | } | |
242 | } | |
243 | v->introducer = introducer; | |
244 | v->dbit = dbit; | |
245 | v->b = b; | |
246 | return buflen; /* return number of bytes in the output buffer */ | |
247 | } | |
248 | ||
475be4d8 JP |
249 | /* |
250 | * DecodeStream receives V.110 coded data from the input stream. It recovers the | |
1da177e4 LT |
251 | * original frames. |
252 | * The input stream doesn't need to be framed | |
253 | */ | |
254 | struct sk_buff * | |
475be4d8 | 255 | isdn_v110_decode(isdn_v110_stream *v, struct sk_buff *skb) |
1da177e4 LT |
256 | { |
257 | int i; | |
258 | int j; | |
259 | int len; | |
260 | unsigned char *v110_buf; | |
261 | unsigned char *rbuf; | |
262 | ||
263 | if (!skb) { | |
264 | printk(KERN_WARNING "isdn_v110_decode called with NULL skb!\n"); | |
265 | return NULL; | |
266 | } | |
267 | rbuf = skb->data; | |
268 | len = skb->len; | |
269 | if (v == NULL) { | |
270 | /* invalid handle, no chance to proceed */ | |
271 | printk(KERN_WARNING "isdn_v110_decode called with NULL stream!\n"); | |
272 | dev_kfree_skb(skb); | |
273 | return NULL; | |
274 | } | |
275 | if (v->decodelen == 0) /* cache empty? */ | |
276 | for (; len > 0; len--, rbuf++) /* scan for SyncHeader in buf */ | |
277 | if ((*rbuf & v->key) == 0) | |
278 | break; /* found first byte */ | |
279 | if (len == 0) { | |
280 | dev_kfree_skb(skb); | |
281 | return NULL; | |
282 | } | |
283 | /* copy new data to decode-buffer */ | |
284 | memcpy(&(v->decodebuf[v->decodelen]), rbuf, len); | |
285 | v->decodelen += len; | |
475be4d8 | 286 | ReSync: |
1da177e4 LT |
287 | if (v->decodelen < v->nbytes) { /* got a new header ? */ |
288 | dev_kfree_skb(skb); | |
289 | return NULL; /* no, try later */ | |
290 | } | |
291 | if (ValidHeaderBytes(v) != v->nbytes) { /* is that a valid header? */ | |
292 | SyncHeader(v); /* no -> look for header */ | |
293 | goto ReSync; | |
294 | } | |
295 | len = (v->decodelen - (v->decodelen % (10 * v->nbytes))) / v->nbytes; | |
296 | if ((v110_buf = kmalloc(len, GFP_ATOMIC)) == NULL) { | |
297 | printk(KERN_WARNING "isdn_v110_decode: Couldn't allocate v110_buf\n"); | |
298 | dev_kfree_skb(skb); | |
299 | return NULL; | |
300 | } | |
301 | for (i = 0; i < len; i++) { | |
302 | v110_buf[i] = 0; | |
303 | for (j = 0; j < v->nbytes; j++) | |
304 | v110_buf[i] |= (v->decodebuf[(i * v->nbytes) + j] & v->key) << (8 - ((j + 1) * v->nbits)); | |
305 | v110_buf[i] = FlipBits(v110_buf[i], v->nbits); | |
306 | } | |
307 | v->decodelen = (v->decodelen % (10 * v->nbytes)); | |
308 | memcpy(v->decodebuf, &(v->decodebuf[len * v->nbytes]), v->decodelen); | |
309 | ||
310 | skb_trim(skb, DecodeMatrix(v, v110_buf, len, skb->data)); | |
311 | kfree(v110_buf); | |
312 | if (skb->len) | |
313 | return skb; | |
314 | else { | |
315 | kfree_skb(skb); | |
316 | return NULL; | |
317 | } | |
318 | } | |
319 | ||
320 | /* EncodeMatrix takes input data in buf, len is the bytecount. | |
321 | Data is encoded into v110 frames in m. Return value is the number of | |
322 | matrix-lines generated. | |
475be4d8 | 323 | */ |
1da177e4 LT |
324 | static int |
325 | EncodeMatrix(unsigned char *buf, int len, unsigned char *m, int mlen) | |
326 | { | |
327 | int line = 0; | |
328 | int i = 0; | |
329 | int mbit = 128; | |
330 | int dbit = 1; | |
331 | int introducer = 3; | |
332 | int ibit[] = {0, 1, 1}; | |
333 | ||
334 | while ((i < len) && (line < mlen)) { /* while we still have input data */ | |
335 | switch (line % 10) { /* in which line of the matrix are we? */ | |
475be4d8 JP |
336 | case 0: |
337 | m[line++] = 0x00; /* line 0 is always 0 */ | |
338 | mbit = 128; /* go on with the 7th bit */ | |
339 | break; | |
340 | case 5: | |
341 | m[line++] = 0xbf; /* line 5 is always 10111111 */ | |
342 | mbit = 128; /* go on with the 7th bit */ | |
343 | break; | |
1da177e4 LT |
344 | } |
345 | if (line >= mlen) { | |
346 | printk(KERN_WARNING "isdn_v110 (EncodeMatrix): buffer full!\n"); | |
347 | return line; | |
348 | } | |
349 | next_bit: | |
350 | switch (mbit) { /* leftmost or rightmost bit ? */ | |
475be4d8 JP |
351 | case 1: |
352 | line++; /* rightmost -> go to next line */ | |
353 | if (line >= mlen) { | |
354 | printk(KERN_WARNING "isdn_v110 (EncodeMatrix): buffer full!\n"); | |
355 | return line; | |
356 | } | |
357 | case 128: | |
358 | m[line] = 128; /* leftmost -> set byte to 1000000 */ | |
359 | mbit = 64; /* current bit in the matrix line */ | |
360 | continue; | |
1da177e4 LT |
361 | } |
362 | if (introducer) { /* set 110 sequence ? */ | |
363 | introducer--; /* set on digit less */ | |
364 | m[line] |= ibit[introducer] ? mbit : 0; /* set corresponding bit */ | |
365 | mbit >>= 1; /* bit of matrix line >> 1 */ | |
366 | goto next_bit; /* and go on there */ | |
367 | } /* else push data bits into the matrix! */ | |
368 | m[line] |= (buf[i] & dbit) ? mbit : 0; /* set data bit in matrix */ | |
369 | if (dbit == 128) { /* was it the last one? */ | |
370 | dbit = 1; /* then go on with first bit of */ | |
371 | i++; /* next byte in input buffer */ | |
372 | if (i < len) /* input buffer done ? */ | |
373 | introducer = 3; /* no, write introducer 110 */ | |
374 | else { /* input buffer done ! */ | |
375 | m[line] |= (mbit - 1) & 0xfe; /* set remaining bits in line to 1 */ | |
376 | break; | |
377 | } | |
378 | } else /* not the last data bit */ | |
379 | dbit <<= 1; /* then go to next data bit */ | |
380 | mbit >>= 1; /* go to next bit of matrix */ | |
381 | goto next_bit; | |
382 | ||
383 | } | |
384 | /* if necessary, generate remaining lines of the matrix... */ | |
385 | if ((line) && ((line + 10) < mlen)) | |
386 | switch (++line % 10) { | |
475be4d8 JP |
387 | case 1: |
388 | m[line++] = 0xfe; | |
389 | case 2: | |
390 | m[line++] = 0xfe; | |
391 | case 3: | |
392 | m[line++] = 0xfe; | |
393 | case 4: | |
394 | m[line++] = 0xfe; | |
395 | case 5: | |
396 | m[line++] = 0xbf; | |
397 | case 6: | |
398 | m[line++] = 0xfe; | |
399 | case 7: | |
400 | m[line++] = 0xfe; | |
401 | case 8: | |
402 | m[line++] = 0xfe; | |
403 | case 9: | |
404 | m[line++] = 0xfe; | |
1da177e4 LT |
405 | } |
406 | return line; /* that's how many lines we have */ | |
407 | } | |
408 | ||
409 | /* | |
410 | * Build a sync frame. | |
411 | */ | |
412 | static struct sk_buff * | |
413 | isdn_v110_sync(isdn_v110_stream *v) | |
414 | { | |
415 | struct sk_buff *skb; | |
416 | ||
417 | if (v == NULL) { | |
418 | /* invalid handle, no chance to proceed */ | |
419 | printk(KERN_WARNING "isdn_v110_sync called with NULL stream!\n"); | |
420 | return NULL; | |
421 | } | |
422 | if ((skb = dev_alloc_skb(v->framelen + v->skbres))) { | |
423 | skb_reserve(skb, v->skbres); | |
424 | memcpy(skb_put(skb, v->framelen), v->OfflineFrame, v->framelen); | |
425 | } | |
426 | return skb; | |
427 | } | |
428 | ||
429 | /* | |
430 | * Build an idle frame. | |
431 | */ | |
432 | static struct sk_buff * | |
433 | isdn_v110_idle(isdn_v110_stream *v) | |
434 | { | |
435 | struct sk_buff *skb; | |
436 | ||
437 | if (v == NULL) { | |
438 | /* invalid handle, no chance to proceed */ | |
439 | printk(KERN_WARNING "isdn_v110_sync called with NULL stream!\n"); | |
440 | return NULL; | |
441 | } | |
442 | if ((skb = dev_alloc_skb(v->framelen + v->skbres))) { | |
443 | skb_reserve(skb, v->skbres); | |
444 | memcpy(skb_put(skb, v->framelen), v->OnlineFrame, v->framelen); | |
445 | } | |
446 | return skb; | |
447 | } | |
448 | ||
449 | struct sk_buff * | |
475be4d8 | 450 | isdn_v110_encode(isdn_v110_stream *v, struct sk_buff *skb) |
1da177e4 LT |
451 | { |
452 | int i; | |
453 | int j; | |
454 | int rlen; | |
455 | int mlen; | |
456 | int olen; | |
457 | int size; | |
458 | int sval1; | |
459 | int sval2; | |
460 | int nframes; | |
461 | unsigned char *v110buf; | |
462 | unsigned char *rbuf; | |
463 | struct sk_buff *nskb; | |
464 | ||
465 | if (v == NULL) { | |
466 | /* invalid handle, no chance to proceed */ | |
467 | printk(KERN_WARNING "isdn_v110_encode called with NULL stream!\n"); | |
468 | return NULL; | |
469 | } | |
470 | if (!skb) { | |
471 | /* invalid skb, no chance to proceed */ | |
472 | printk(KERN_WARNING "isdn_v110_encode called with NULL skb!\n"); | |
473 | return NULL; | |
474 | } | |
475 | rlen = skb->len; | |
476 | nframes = (rlen + 3) / 4; | |
477 | v110buf = v->encodebuf; | |
478 | if ((nframes * 40) > v->maxsize) { | |
479 | size = v->maxsize; | |
480 | rlen = v->maxsize / 40; | |
481 | } else | |
482 | size = nframes * 40; | |
483 | if (!(nskb = dev_alloc_skb(size + v->skbres + sizeof(int)))) { | |
484 | printk(KERN_WARNING "isdn_v110_encode: Couldn't alloc skb\n"); | |
485 | return NULL; | |
486 | } | |
487 | skb_reserve(nskb, v->skbres + sizeof(int)); | |
488 | if (skb->len == 0) { | |
489 | memcpy(skb_put(nskb, v->framelen), v->OnlineFrame, v->framelen); | |
490 | *((int *)skb_push(nskb, sizeof(int))) = 0; | |
491 | return nskb; | |
492 | } | |
493 | mlen = EncodeMatrix(skb->data, rlen, v110buf, size); | |
494 | /* now distribute 2 or 4 bits each to the output stream! */ | |
495 | rbuf = skb_put(nskb, size); | |
496 | olen = 0; | |
497 | sval1 = 8 - v->nbits; | |
498 | sval2 = v->key << sval1; | |
499 | for (i = 0; i < mlen; i++) { | |
500 | v110buf[i] = FlipBits(v110buf[i], v->nbits); | |
501 | for (j = 0; j < v->nbytes; j++) { | |
502 | if (size--) | |
503 | *rbuf++ = ~v->key | (((v110buf[i] << (j * v->nbits)) & sval2) >> sval1); | |
504 | else { | |
505 | printk(KERN_WARNING "isdn_v110_encode: buffers full!\n"); | |
506 | goto buffer_full; | |
507 | } | |
508 | olen++; | |
509 | } | |
510 | } | |
511 | buffer_full: | |
512 | skb_trim(nskb, olen); | |
513 | *((int *)skb_push(nskb, sizeof(int))) = rlen; | |
514 | return nskb; | |
515 | } | |
516 | ||
517 | int | |
1e1a5cc7 | 518 | isdn_v110_stat_callback(int idx, isdn_ctrl *c) |
1da177e4 LT |
519 | { |
520 | isdn_v110_stream *v = NULL; | |
521 | int i; | |
1e1a5cc7 | 522 | int ret = 0; |
1da177e4 LT |
523 | |
524 | if (idx < 0) | |
525 | return 0; | |
526 | switch (c->command) { | |
475be4d8 JP |
527 | case ISDN_STAT_BSENT: |
528 | /* Keep the send-queue of the driver filled | |
529 | * with frames: | |
530 | * If number of outstanding frames < 3, | |
531 | * send down an Idle-Frame (or an Sync-Frame, if | |
532 | * v->SyncInit != 0). | |
533 | */ | |
534 | if (!(v = dev->v110[idx])) | |
535 | return 0; | |
536 | atomic_inc(&dev->v110use[idx]); | |
537 | for (i = 0; i * v->framelen < c->parm.length; i++) { | |
538 | if (v->skbidle > 0) { | |
539 | v->skbidle--; | |
540 | ret = 1; | |
541 | } else { | |
542 | if (v->skbuser > 0) | |
543 | v->skbuser--; | |
544 | ret = 0; | |
545 | } | |
546 | } | |
547 | for (i = v->skbuser + v->skbidle; i < 2; i++) { | |
548 | struct sk_buff *skb; | |
549 | if (v->SyncInit > 0) | |
550 | skb = isdn_v110_sync(v); | |
551 | else | |
552 | skb = isdn_v110_idle(v); | |
553 | if (skb) { | |
554 | if (dev->drv[c->driver]->interface->writebuf_skb(c->driver, c->arg, 1, skb) <= 0) { | |
555 | dev_kfree_skb(skb); | |
556 | break; | |
1da177e4 | 557 | } else { |
475be4d8 JP |
558 | if (v->SyncInit) |
559 | v->SyncInit--; | |
560 | v->skbidle++; | |
1da177e4 | 561 | } |
475be4d8 JP |
562 | } else |
563 | break; | |
564 | } | |
565 | atomic_dec(&dev->v110use[idx]); | |
566 | return ret; | |
567 | case ISDN_STAT_DHUP: | |
568 | case ISDN_STAT_BHUP: | |
569 | while (1) { | |
570 | atomic_inc(&dev->v110use[idx]); | |
571 | if (atomic_dec_and_test(&dev->v110use[idx])) { | |
572 | isdn_v110_close(dev->v110[idx]); | |
573 | dev->v110[idx] = NULL; | |
574 | break; | |
575 | } | |
576 | mdelay(1); | |
577 | } | |
578 | break; | |
579 | case ISDN_STAT_BCONN: | |
580 | if (dev->v110emu[idx] && (dev->v110[idx] == NULL)) { | |
581 | int hdrlen = dev->drv[c->driver]->interface->hl_hdrlen; | |
582 | int maxsize = dev->drv[c->driver]->interface->maxbufsize; | |
583 | atomic_inc(&dev->v110use[idx]); | |
584 | switch (dev->v110emu[idx]) { | |
585 | case ISDN_PROTO_L2_V11096: | |
586 | dev->v110[idx] = isdn_v110_open(V110_9600, hdrlen, maxsize); | |
587 | break; | |
588 | case ISDN_PROTO_L2_V11019: | |
589 | dev->v110[idx] = isdn_v110_open(V110_19200, hdrlen, maxsize); | |
590 | break; | |
591 | case ISDN_PROTO_L2_V11038: | |
592 | dev->v110[idx] = isdn_v110_open(V110_38400, hdrlen, maxsize); | |
593 | break; | |
594 | default:; | |
1da177e4 | 595 | } |
475be4d8 JP |
596 | if ((v = dev->v110[idx])) { |
597 | while (v->SyncInit) { | |
598 | struct sk_buff *skb = isdn_v110_sync(v); | |
1da177e4 LT |
599 | if (dev->drv[c->driver]->interface->writebuf_skb(c->driver, c->arg, 1, skb) <= 0) { |
600 | dev_kfree_skb(skb); | |
475be4d8 | 601 | /* Unable to send, try later */ |
1da177e4 | 602 | break; |
1da177e4 | 603 | } |
475be4d8 JP |
604 | v->SyncInit--; |
605 | v->skbidle++; | |
1da177e4 | 606 | } |
475be4d8 JP |
607 | } else |
608 | printk(KERN_WARNING "isdn_v110: Couldn't open stream for chan %d\n", idx); | |
609 | atomic_dec(&dev->v110use[idx]); | |
610 | } | |
611 | break; | |
612 | default: | |
613 | return 0; | |
1da177e4 LT |
614 | } |
615 | return 0; | |
616 | } |