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 			fallthrough;
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);
618