1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3 * isdnhdlc.c -- General purpose ISDN HDLC decoder.
4 *
5 * Copyright (C)
6 * 2009 Karsten Keil <keil@b1-systems.de>
7 * 2002 Wolfgang Mües <wolfgang@iksw-muees.de>
8 * 2001 Frode Isaksen <fisaksen@bewan.com>
9 * 2001 Kai Germaschewski <kai.germaschewski@gmx.de>
10 */
11
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/crc-ccitt.h>
15 #include <linux/bitrev.h>
16 #include "isdnhdlc.h"
17
18 /*-------------------------------------------------------------------*/
19
20 MODULE_AUTHOR("Wolfgang Mües <wolfgang@iksw-muees.de>, "
21 "Frode Isaksen <fisaksen@bewan.com>, "
22 "Kai Germaschewski <kai.germaschewski@gmx.de>");
23 MODULE_DESCRIPTION("General purpose ISDN HDLC decoder");
24 MODULE_LICENSE("GPL");
25
26 /*-------------------------------------------------------------------*/
27
28 enum {
29 HDLC_FAST_IDLE, HDLC_GET_FLAG_B0, HDLC_GETFLAG_B1A6, HDLC_GETFLAG_B7,
30 HDLC_GET_DATA, HDLC_FAST_FLAG
31 };
32
33 enum {
34 HDLC_SEND_DATA, HDLC_SEND_CRC1, HDLC_SEND_FAST_FLAG,
35 HDLC_SEND_FIRST_FLAG, HDLC_SEND_CRC2, HDLC_SEND_CLOSING_FLAG,
36 HDLC_SEND_IDLE1, HDLC_SEND_FAST_IDLE, HDLC_SENDFLAG_B0,
37 HDLC_SENDFLAG_B1A6, HDLC_SENDFLAG_B7, STOPPED, HDLC_SENDFLAG_ONE
38 };
39
40 void isdnhdlc_rcv_init(struct isdnhdlc_vars *hdlc, u32 features)
41 {
42 memset(hdlc, 0, sizeof(struct isdnhdlc_vars));
43 hdlc->state = HDLC_GET_DATA;
44 if (features & HDLC_56KBIT)
45 hdlc->do_adapt56 = 1;
46 if (features & HDLC_BITREVERSE)
47 hdlc->do_bitreverse = 1;
48 }
49 EXPORT_SYMBOL(isdnhdlc_out_init);
50
51 void isdnhdlc_out_init(struct isdnhdlc_vars *hdlc, u32 features)
52 {
53 memset(hdlc, 0, sizeof(struct isdnhdlc_vars));
54 if (features & HDLC_DCHANNEL) {
55 hdlc->dchannel = 1;
56 hdlc->state = HDLC_SEND_FIRST_FLAG;
57 } else {
58 hdlc->dchannel = 0;
59 hdlc->state = HDLC_SEND_FAST_FLAG;
60 hdlc->ffvalue = 0x7e;
61 }
62 hdlc->cbin = 0x7e;
63 if (features & HDLC_56KBIT) {
64 hdlc->do_adapt56 = 1;
65 hdlc->state = HDLC_SENDFLAG_B0;
66 } else
67 hdlc->data_bits = 8;
68 if (features & HDLC_BITREVERSE)
69 hdlc->do_bitreverse = 1;
70 }
71 EXPORT_SYMBOL(isdnhdlc_rcv_init);
72
73 static int
74 check_frame(struct isdnhdlc_vars *hdlc)
75 {
76 int status;
77
78 if (hdlc->dstpos < 2) /* too small - framing error */
79 status = -HDLC_FRAMING_ERROR;
80 else if (hdlc->crc != 0xf0b8) /* crc error */
81 status = -HDLC_CRC_ERROR;
82 else {
83 /* remove CRC */
84 hdlc->dstpos -= 2;
85 /* good frame */
86 status = hdlc->dstpos;
87 }
88 return status;
89 }
90
91 /*
92 isdnhdlc_decode - decodes HDLC frames from a transparent bit stream.
93
94 The source buffer is scanned for valid HDLC frames looking for
95 flags (01111110) to indicate the start of a frame. If the start of
96 the frame is found, the bit stuffing is removed (0 after 5 1's).
97 When a new flag is found, the complete frame has been received
98 and the CRC is checked.
99 If a valid frame is found, the function returns the frame length
100 excluding the CRC with the bit HDLC_END_OF_FRAME set.
101 If the beginning of a valid frame is found, the function returns
102 the length.
103 If a framing error is found (too many 1s and not a flag) the function
104 returns the length with the bit HDLC_FRAMING_ERROR set.
105 If a CRC error is found the function returns the length with the
106 bit HDLC_CRC_ERROR set.
107 If the frame length exceeds the destination buffer size, the function
108 returns the length with the bit HDLC_LENGTH_ERROR set.
109
110 src - source buffer
111 slen - source buffer length
112 count - number of bytes removed (decoded) from the source buffer
113 dst _ destination buffer
114 dsize - destination buffer size
115 returns - number of decoded bytes in the destination buffer and status
116 flag.
117 */
118 int isdnhdlc_decode(struct isdnhdlc_vars *hdlc, const u8 *src, int slen,
119 int *count, u8 *dst, int dsize)
120 {
121 int status = 0;
122
123 static const unsigned char fast_flag[] = {
124 0x00, 0x00, 0x00, 0x20, 0x30, 0x38, 0x3c, 0x3e, 0x3f
125 };
126
127 static const unsigned char fast_flag_value[] = {
128 0x00, 0x7e, 0xfc, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3f
129 };
130
131 static const unsigned char fast_abort[] = {
132 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff
133 };
134
135 #define handle_fast_flag(h) \
136 do { \
137 if (h->cbin == fast_flag[h->bit_shift]) { \
138 h->ffvalue = fast_flag_value[h->bit_shift]; \
139 h->state = HDLC_FAST_FLAG; \
140 h->ffbit_shift = h->bit_shift; \
141 h->bit_shift = 1; \
142 } else { \
143 h->state = HDLC_GET_DATA; \
144 h->data_received = 0; \
145 } \
146 } while (0)
147
148 #define handle_abort(h) \
149 do { \
150 h->shift_reg = fast_abort[h->ffbit_shift - 1]; \
151 h->hdlc_bits1 = h->ffbit_shift - 2; \
152 if (h->hdlc_bits1 < 0) \
153 h->hdlc_bits1 = 0; \
154 h->data_bits = h->ffbit_shift - 1; \
155 h->state = HDLC_GET_DATA; \
156 h->data_received = 0; \
157 } while (0)
158
159 *count = slen;
160
161 while (slen > 0) {
162 if (hdlc->bit_shift == 0) {
163 /* the code is for bitreverse streams */
164 if (hdlc->do_bitreverse == 0)
165 hdlc->cbin = bitrev8(*src++);
166 else
167 hdlc->cbin = *src++;
168 slen--;
169 hdlc->bit_shift = 8;
170 if (hdlc->do_adapt56)
171 hdlc->bit_shift--;
172 }
173
174 switch (hdlc->state) {
175 case STOPPED:
176 return 0;
177 case HDLC_FAST_IDLE:
178 if (hdlc->cbin == 0xff) {
179 hdlc->bit_shift = 0;
180 break;
181 }
182 hdlc->state = HDLC_GET_FLAG_B0;
183 hdlc->hdlc_bits1 = 0;
184 hdlc->bit_shift = 8;
185 break;
186 case HDLC_GET_FLAG_B0:
187 if (!(hdlc->cbin & 0x80)) {
188 hdlc->state = HDLC_GETFLAG_B1A6;
189 hdlc->hdlc_bits1 = 0;
190 } else {
191 if ((!hdlc->do_adapt56) &&
192 (++hdlc->hdlc_bits1 >= 8) &&
193 (hdlc->bit_shift == 1))
194 hdlc->state = HDLC_FAST_IDLE;
195 }
196 hdlc->cbin <<= 1;
197 hdlc->bit_shift--;
198 break;
199 case HDLC_GETFLAG_B1A6:
200 if (hdlc->cbin & 0x80) {
201 hdlc->hdlc_bits1++;
202 if (hdlc->hdlc_bits1 == 6)
203 hdlc->state = HDLC_GETFLAG_B7;
204 } else
205 hdlc->hdlc_bits1 = 0;
206 hdlc->cbin <<= 1;
207 hdlc->bit_shift--;
208 break;
209 case HDLC_GETFLAG_B7:
210 if (hdlc->cbin & 0x80) {
211 hdlc->state = HDLC_GET_FLAG_B0;
212 } else {
213 hdlc->state = HDLC_GET_DATA;
214 hdlc->crc = 0xffff;
215 hdlc->shift_reg = 0;
216 hdlc->hdlc_bits1 = 0;
217 hdlc->data_bits = 0;
218 hdlc->data_received = 0;
219 }
220 hdlc->cbin <<= 1;
221 hdlc->bit_shift--;
222 break;
223 case HDLC_GET_DATA:
224 if (hdlc->cbin & 0x80) {
225 hdlc->hdlc_bits1++;
226 switch (hdlc->hdlc_bits1) {
227 case 6:
228 break;
229 case 7:
230 if (hdlc->data_received)
231 /* bad frame */
232 status = -HDLC_FRAMING_ERROR;
233 if (!hdlc->do_adapt56) {
234 if (hdlc->cbin == fast_abort
235 [hdlc->bit_shift + 1]) {
236 hdlc->state =
237 HDLC_FAST_IDLE;
238 hdlc->bit_shift = 1;
239 break;
240 }
241 } else
242 hdlc->state = HDLC_GET_FLAG_B0;
243 break;
244 default:
245 hdlc->shift_reg >>= 1;
246 hdlc->shift_reg |= 0x80;
247 hdlc->data_bits++;
248 break;
249 }
250 } else {
251 switch (hdlc->hdlc_bits1) {
252 case 5:
253 break;
254 case 6:
255 if (hdlc->data_received)
256 status = check_frame(hdlc);
257 hdlc->crc = 0xffff;
258 hdlc->shift_reg = 0;
259 hdlc->data_bits = 0;
260 if (!hdlc->do_adapt56)
261 handle_fast_flag(hdlc);
262 else {
263 hdlc->state = HDLC_GET_DATA;
264 hdlc->data_received = 0;
265 }
266 break;
267 default:
268 hdlc->shift_reg >>= 1;
269 hdlc->data_bits++;
270 break;
271 }
272 hdlc->hdlc_bits1 = 0;
273 }
274 if (status) {
275 hdlc->dstpos = 0;
276 *count -= slen;
277 hdlc->cbin <<= 1;
278 hdlc->bit_shift--;
279 return status;
280 }
281 if (hdlc->data_bits == 8) {
282 hdlc->data_bits = 0;
283 hdlc->data_received = 1;
284 hdlc->crc = crc_ccitt_byte(hdlc->crc,
285 hdlc->shift_reg);
286
287 /* good byte received */
288 if (hdlc->dstpos < dsize)
289 dst[hdlc->dstpos++] = hdlc->shift_reg;
290 else {
291 /* frame too long */
292 status = -HDLC_LENGTH_ERROR;
293 hdlc->dstpos = 0;
294 }
295 }
296 hdlc->cbin <<= 1;
297 hdlc->bit_shift--;
298 break;
299 case HDLC_FAST_FLAG:
300 if (hdlc->cbin == hdlc->ffvalue) {
301 hdlc->bit_shift = 0;
302 break;
303 } else {
304 if (hdlc->cbin == 0xff) {
305 hdlc->state = HDLC_FAST_IDLE;
306 hdlc->bit_shift = 0;
307 } else if (hdlc->ffbit_shift == 8) {
308 hdlc->state = HDLC_GETFLAG_B7;
309 break;
310 } else
311 handle_abort(hdlc);
312 }
313 break;
314 default:
315 break;
316 }
317 }
318 *count -= slen;
319 return 0;
320 }
321 EXPORT_SYMBOL(isdnhdlc_decode);
322 /*
323 isdnhdlc_encode - encodes HDLC frames to a transparent bit stream.
324
325 The bit stream starts with a beginning flag (01111110). After
326 that each byte is added to the bit stream with bit stuffing added
327 (0 after 5 1's).
328 When the last byte has been removed from the source buffer, the
329 CRC (2 bytes is added) and the frame terminates with the ending flag.
330 For the dchannel, the idle character (all 1's) is also added at the end.
331 If this function is called with empty source buffer (slen=0), flags or
332 idle character will be generated.
333
334 src - source buffer
335 slen - source buffer length
336 count - number of bytes removed (encoded) from source buffer
337 dst _ destination buffer
338 dsize - destination buffer size
339 returns - number of encoded bytes in the destination buffer
340 */
341 int isdnhdlc_encode(struct isdnhdlc_vars *hdlc, const u8 *src, u16 slen,
342 int *count, u8 *dst, int dsize)
343 {
344 static const unsigned char xfast_flag_value[] = {
345 0x7e, 0x3f, 0x9f, 0xcf, 0xe7, 0xf3, 0xf9, 0xfc, 0x7e
346 };
347
348 int len = 0;
349
350 *count = slen;
351
352 /* special handling for one byte frames */
353 if ((slen == 1) && (hdlc->state == HDLC_SEND_FAST_FLAG))
354 hdlc->state = HDLC_SENDFLAG_ONE;
355 while (dsize > 0) {
356 if (hdlc->bit_shift == 0) {
357 if (slen && !hdlc->do_closing) {
358 hdlc->shift_reg = *src++;
359 slen--;
360 if (slen == 0)
361 /* closing sequence, CRC + flag(s) */
362 hdlc->do_closing = 1;
363 hdlc->bit_shift = 8;
364 } else {
365 if (hdlc->state == HDLC_SEND_DATA) {
366 if (hdlc->data_received) {
367 hdlc->state = HDLC_SEND_CRC1;
368 hdlc->crc ^= 0xffff;
369 hdlc->bit_shift = 8;
370 hdlc->shift_reg =
371 hdlc->crc & 0xff;
372 } else if (!hdlc->do_adapt56)
373 hdlc->state =
374 HDLC_SEND_FAST_FLAG;
375 else
376 hdlc->state =
377 HDLC_SENDFLAG_B0;
378 }
379
380 }
381 }
382
383 switch (hdlc->state) {
384 case STOPPED:
385 while (dsize--)
386 *dst++ = 0xff;
387 return dsize;
388 case HDLC_SEND_FAST_FLAG:
389 hdlc->do_closing = 0;
390 if (slen == 0) {
391 /* the code is for bitreverse streams */
392 if (hdlc->do_bitreverse == 0)
393 *dst++ = bitrev8(hdlc->ffvalue);
394 else
395 *dst++ = hdlc->ffvalue;
396 len++;
397 dsize--;
398 break;
399 }
400 /* fall through */
401 case HDLC_SENDFLAG_ONE:
402 if (hdlc->bit_shift == 8) {
403 hdlc->cbin = hdlc->ffvalue >>
404 (8 - hdlc->data_bits);
405 hdlc->state = HDLC_SEND_DATA;
406 hdlc->crc = 0xffff;
407 hdlc->hdlc_bits1 = 0;
408 hdlc->data_received = 1;
409 }
410 break;
411 case HDLC_SENDFLAG_B0:
412 hdlc->do_closing = 0;
413 hdlc->cbin <<= 1;
414 hdlc->data_bits++;
415 hdlc->hdlc_bits1 = 0;
416 hdlc->state = HDLC_SENDFLAG_B1A6;
417 break;
418 case HDLC_SENDFLAG_B1A6:
419 hdlc->cbin <<= 1;
420 hdlc->data_bits++;
421 hdlc->cbin++;
422 if (++hdlc->hdlc_bits1 == 6)
423 hdlc->state = HDLC_SENDFLAG_B7;
424 break;
425 case HDLC_SENDFLAG_B7:
426 hdlc->cbin <<= 1;
427 hdlc->data_bits++;
428 if (slen == 0) {
429 hdlc->state = HDLC_SENDFLAG_B0;
430 break;
431 }
432 if (hdlc->bit_shift == 8) {
433 hdlc->state = HDLC_SEND_DATA;
434 hdlc->crc = 0xffff;
435 hdlc->hdlc_bits1 = 0;
436 hdlc->data_received = 1;
437 }
438 break;
439 case HDLC_SEND_FIRST_FLAG:
440 hdlc->data_received = 1;
441 if (hdlc->data_bits == 8) {
442 hdlc->state = HDLC_SEND_DATA;
443 hdlc->crc = 0xffff;
444 hdlc->hdlc_bits1 = 0;
445 break;
446 }
447 hdlc->cbin <<= 1;
448 hdlc->data_bits++;
449 if (hdlc->shift_reg & 0x01)
450 hdlc->cbin++;
451 hdlc->shift_reg >>= 1;
452 hdlc->bit_shift--;
453 if (hdlc->bit_shift == 0) {
454 hdlc->state = HDLC_SEND_DATA;
455 hdlc->crc = 0xffff;
456 hdlc->hdlc_bits1 = 0;
457 }
458 break;
459 case HDLC_SEND_DATA:
460 hdlc->cbin <<= 1;
461 hdlc->data_bits++;
462 if (hdlc->hdlc_bits1 == 5) {
463 hdlc->hdlc_bits1 = 0;
464 break;
465 }
466 if (hdlc->bit_shift == 8)
467 hdlc->crc = crc_ccitt_byte(hdlc->crc,
468 hdlc->shift_reg);
469 if (hdlc->shift_reg & 0x01) {
470 hdlc->hdlc_bits1++;
471 hdlc->cbin++;
472 hdlc->shift_reg >>= 1;
473 hdlc->bit_shift--;
474 } else {
475 hdlc->hdlc_bits1 = 0;
476 hdlc->shift_reg >>= 1;
477 hdlc->bit_shift--;
478 }
479 break;
480 case HDLC_SEND_CRC1:
481 hdlc->cbin <<= 1;
482 hdlc->data_bits++;
483 if (hdlc->hdlc_bits1 == 5) {
484 hdlc->hdlc_bits1 = 0;
485 break;
486 }
487 if (hdlc->shift_reg & 0x01) {
488 hdlc->hdlc_bits1++;
489 hdlc->cbin++;
490 hdlc->shift_reg >>= 1;
491 hdlc->bit_shift--;
492 } else {
493 hdlc->hdlc_bits1 = 0;
494 hdlc->shift_reg >>= 1;
495 hdlc->bit_shift--;
496 }
497 if (hdlc->bit_shift == 0) {
498 hdlc->shift_reg = (hdlc->crc >> 8);
499 hdlc->state = HDLC_SEND_CRC2;
500 hdlc->bit_shift = 8;
501 }
502 break;
503 case HDLC_SEND_CRC2:
504 hdlc->cbin <<= 1;
505 hdlc->data_bits++;
506 if (hdlc->hdlc_bits1 == 5) {
507 hdlc->hdlc_bits1 = 0;
508 break;
509 }
510 if (hdlc->shift_reg & 0x01) {
511 hdlc->hdlc_bits1++;
512 hdlc->cbin++;
513 hdlc->shift_reg >>= 1;
514 hdlc->bit_shift--;
515 } else {
516 hdlc->hdlc_bits1 = 0;
517 hdlc->shift_reg >>= 1;
518 hdlc->bit_shift--;
519 }
520 if (hdlc->bit_shift == 0) {
521 hdlc->shift_reg = 0x7e;
522 hdlc->state = HDLC_SEND_CLOSING_FLAG;
523 hdlc->bit_shift = 8;
524 }
525 break;
526 case HDLC_SEND_CLOSING_FLAG:
527 hdlc->cbin <<= 1;
528 hdlc->data_bits++;
529 if (hdlc->hdlc_bits1 == 5) {
530 hdlc->hdlc_bits1 = 0;
531 break;
532 }
533 if (hdlc->shift_reg & 0x01)
534 hdlc->cbin++;
535 hdlc->shift_reg >>= 1;
536 hdlc->bit_shift--;
537 if (hdlc->bit_shift == 0) {
538 hdlc->ffvalue =
539 xfast_flag_value[hdlc->data_bits];
540 if (hdlc->dchannel) {
541 hdlc->ffvalue = 0x7e;
542 hdlc->state = HDLC_SEND_IDLE1;
543 hdlc->bit_shift = 8-hdlc->data_bits;
544 if (hdlc->bit_shift == 0)
545 hdlc->state =
546 HDLC_SEND_FAST_IDLE;
547 } else {
548 if (!hdlc->do_adapt56) {
549 hdlc->state =
550 HDLC_SEND_FAST_FLAG;
551 hdlc->data_received = 0;
552 } else {
553 hdlc->state = HDLC_SENDFLAG_B0;
554 hdlc->data_received = 0;
555 }
556 /* Finished this frame, send flags */
557 if (dsize > 1)
558 dsize = 1;
559 }
560 }
561 break;
562 case HDLC_SEND_IDLE1:
563 hdlc->do_closing = 0;
564 hdlc->cbin <<= 1;
565 hdlc->cbin++;
566 hdlc->data_bits++;
567 hdlc->bit_shift--;
568 if (hdlc->bit_shift == 0) {
569 hdlc->state = HDLC_SEND_FAST_IDLE;
570 hdlc->bit_shift = 0;
571 }
572 break;
573 case HDLC_SEND_FAST_IDLE:
574 hdlc->do_closing = 0;
575 hdlc->cbin = 0xff;
576 hdlc->data_bits = 8;
577 if (hdlc->bit_shift == 8) {
578 hdlc->cbin = 0x7e;
579 hdlc->state = HDLC_SEND_FIRST_FLAG;
580 } else {
581 /* the code is for bitreverse streams */
582 if (hdlc->do_bitreverse == 0)
583 *dst++ = bitrev8(hdlc->cbin);
584 else
585 *dst++ = hdlc->cbin;
586 hdlc->bit_shift = 0;
587 hdlc->data_bits = 0;
588 len++;
589 dsize = 0;
590 }
591 break;
592 default:
593 break;
594 }
595 if (hdlc->do_adapt56) {
596 if (hdlc->data_bits == 7) {
597 hdlc->cbin <<= 1;
598 hdlc->cbin++;
599 hdlc->data_bits++;
600 }
601 }
602 if (hdlc->data_bits == 8) {
603 /* the code is for bitreverse streams */
604 if (hdlc->do_bitreverse == 0)
605 *dst++ = bitrev8(hdlc->cbin);
606 else
607 *dst++ = hdlc->cbin;
608 hdlc->data_bits = 0;
609 len++;
610 dsize--;
611 }
612 }
613 *count -= slen;
614
615 return len;
616 }
617 EXPORT_SYMBOL(isdnhdlc_encode);