2 * Driver for ST5481 USB ISDN modem
5 * Copyright 2001 by Frode Isaksen <fisaksen@bewan.com>
6 * 2001 by Kai Germaschewski <kai.germaschewski@gmx.de>
8 * This software may be used and distributed according to the terms
9 * of the GNU General Public License, incorporated herein by reference.
13 #include "st5481_hdlc.h"
15 static const unsigned short int crc16_tab[] = {
16 0x0000,0x1189,0x2312,0x329b,0x4624,0x57ad,0x6536,0x74bf,
17 0x8c48,0x9dc1,0xaf5a,0xbed3,0xca6c,0xdbe5,0xe97e,0xf8f7,
18 0x1081,0x0108,0x3393,0x221a,0x56a5,0x472c,0x75b7,0x643e,
19 0x9cc9,0x8d40,0xbfdb,0xae52,0xdaed,0xcb64,0xf9ff,0xe876,
20 0x2102,0x308b,0x0210,0x1399,0x6726,0x76af,0x4434,0x55bd,
21 0xad4a,0xbcc3,0x8e58,0x9fd1,0xeb6e,0xfae7,0xc87c,0xd9f5,
22 0x3183,0x200a,0x1291,0x0318,0x77a7,0x662e,0x54b5,0x453c,
23 0xbdcb,0xac42,0x9ed9,0x8f50,0xfbef,0xea66,0xd8fd,0xc974,
24 0x4204,0x538d,0x6116,0x709f,0x0420,0x15a9,0x2732,0x36bb,
25 0xce4c,0xdfc5,0xed5e,0xfcd7,0x8868,0x99e1,0xab7a,0xbaf3,
26 0x5285,0x430c,0x7197,0x601e,0x14a1,0x0528,0x37b3,0x263a,
27 0xdecd,0xcf44,0xfddf,0xec56,0x98e9,0x8960,0xbbfb,0xaa72,
28 0x6306,0x728f,0x4014,0x519d,0x2522,0x34ab,0x0630,0x17b9,
29 0xef4e,0xfec7,0xcc5c,0xddd5,0xa96a,0xb8e3,0x8a78,0x9bf1,
30 0x7387,0x620e,0x5095,0x411c,0x35a3,0x242a,0x16b1,0x0738,
31 0xffcf,0xee46,0xdcdd,0xcd54,0xb9eb,0xa862,0x9af9,0x8b70,
32 0x8408,0x9581,0xa71a,0xb693,0xc22c,0xd3a5,0xe13e,0xf0b7,
33 0x0840,0x19c9,0x2b52,0x3adb,0x4e64,0x5fed,0x6d76,0x7cff,
34 0x9489,0x8500,0xb79b,0xa612,0xd2ad,0xc324,0xf1bf,0xe036,
35 0x18c1,0x0948,0x3bd3,0x2a5a,0x5ee5,0x4f6c,0x7df7,0x6c7e,
36 0xa50a,0xb483,0x8618,0x9791,0xe32e,0xf2a7,0xc03c,0xd1b5,
37 0x2942,0x38cb,0x0a50,0x1bd9,0x6f66,0x7eef,0x4c74,0x5dfd,
38 0xb58b,0xa402,0x9699,0x8710,0xf3af,0xe226,0xd0bd,0xc134,
39 0x39c3,0x284a,0x1ad1,0x0b58,0x7fe7,0x6e6e,0x5cf5,0x4d7c,
40 0xc60c,0xd785,0xe51e,0xf497,0x8028,0x91a1,0xa33a,0xb2b3,
41 0x4a44,0x5bcd,0x6956,0x78df,0x0c60,0x1de9,0x2f72,0x3efb,
42 0xd68d,0xc704,0xf59f,0xe416,0x90a9,0x8120,0xb3bb,0xa232,
43 0x5ac5,0x4b4c,0x79d7,0x685e,0x1ce1,0x0d68,0x3ff3,0x2e7a,
44 0xe70e,0xf687,0xc41c,0xd595,0xa12a,0xb0a3,0x8238,0x93b1,
45 0x6b46,0x7acf,0x4854,0x59dd,0x2d62,0x3ceb,0x0e70,0x1ff9,
46 0xf78f,0xe606,0xd49d,0xc514,0xb1ab,0xa022,0x92b9,0x8330,
47 0x7bc7,0x6a4e,0x58d5,0x495c,0x3de3,0x2c6a,0x1ef1,0x0f78
53 HDLC_FAST_IDLE,HDLC_GET_FLAG_B0,HDLC_GETFLAG_B1A6,HDLC_GETFLAG_B7,
54 HDLC_GET_DATA,HDLC_FAST_FLAG
58 HDLC_SEND_DATA,HDLC_SEND_CRC1,HDLC_SEND_FAST_FLAG,
59 HDLC_SEND_FIRST_FLAG,HDLC_SEND_CRC2,HDLC_SEND_CLOSING_FLAG,
60 HDLC_SEND_IDLE1,HDLC_SEND_FAST_IDLE,HDLC_SENDFLAG_B0,
61 HDLC_SENDFLAG_B1A6,HDLC_SENDFLAG_B7,STOPPED
65 hdlc_rcv_init(struct hdlc_vars *hdlc, int do_adapt56)
70 hdlc->ffbit_shift = 0;
71 hdlc->data_received = 0;
72 hdlc->state = HDLC_GET_DATA;
73 hdlc->do_adapt56 = do_adapt56;
83 hdlc_out_init(struct hdlc_vars *hdlc, int is_d_channel, int do_adapt56)
88 hdlc->ffbit_shift = 0;
89 hdlc->data_received = 0;
94 hdlc->state = HDLC_SEND_FIRST_FLAG;
97 hdlc->state = HDLC_SEND_FAST_FLAG;
103 hdlc->do_adapt56 = 1;
105 hdlc->state = HDLC_SENDFLAG_B0;
107 hdlc->do_adapt56 = 0;
114 hdlc_decode - decodes HDLC frames from a transparent bit stream.
116 The source buffer is scanned for valid HDLC frames looking for
117 flags (01111110) to indicate the start of a frame. If the start of
118 the frame is found, the bit stuffing is removed (0 after 5 1's).
119 When a new flag is found, the complete frame has been received
120 and the CRC is checked.
121 If a valid frame is found, the function returns the frame length
122 excluding the CRC with the bit HDLC_END_OF_FRAME set.
123 If the beginning of a valid frame is found, the function returns
125 If a framing error is found (too many 1s and not a flag) the function
126 returns the length with the bit HDLC_FRAMING_ERROR set.
127 If a CRC error is found the function returns the length with the
128 bit HDLC_CRC_ERROR set.
129 If the frame length exceeds the destination buffer size, the function
130 returns the length with the bit HDLC_LENGTH_ERROR set.
133 slen - source buffer length
134 count - number of bytes removed (decoded) from the source buffer
135 dst _ destination buffer
136 dsize - destination buffer size
137 returns - number of decoded bytes in the destination buffer and status
140 int hdlc_decode(struct hdlc_vars *hdlc, const unsigned char *src,
141 int slen, int *count, unsigned char *dst, int dsize)
145 static const unsigned char fast_flag[]={
146 0x00,0x00,0x00,0x20,0x30,0x38,0x3c,0x3e,0x3f
149 static const unsigned char fast_flag_value[]={
150 0x00,0x7e,0xfc,0xf9,0xf3,0xe7,0xcf,0x9f,0x3f
153 static const unsigned char fast_abort[]={
154 0x00,0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfc,0xfe,0xff
160 if(hdlc->bit_shift==0){
164 if(hdlc->do_adapt56){
173 if(hdlc->cbin == 0xff){
177 hdlc->state = HDLC_GET_FLAG_B0;
178 hdlc->hdlc_bits1 = 0;
181 case HDLC_GET_FLAG_B0:
182 if(!(hdlc->cbin & 0x80)) {
183 hdlc->state = HDLC_GETFLAG_B1A6;
184 hdlc->hdlc_bits1 = 0;
186 if(!hdlc->do_adapt56){
187 if(++hdlc->hdlc_bits1 >=8 ) if(hdlc->bit_shift==1)
188 hdlc->state = HDLC_FAST_IDLE;
194 case HDLC_GETFLAG_B1A6:
195 if(hdlc->cbin & 0x80){
197 if(hdlc->hdlc_bits1==6){
198 hdlc->state = HDLC_GETFLAG_B7;
201 hdlc->hdlc_bits1 = 0;
206 case HDLC_GETFLAG_B7:
207 if(hdlc->cbin & 0x80) {
208 hdlc->state = HDLC_GET_FLAG_B0;
210 hdlc->state = HDLC_GET_DATA;
213 hdlc->hdlc_bits1 = 0;
215 hdlc->data_received = 0;
221 if(hdlc->cbin & 0x80){
223 switch(hdlc->hdlc_bits1){
227 if(hdlc->data_received) {
229 status = -HDLC_FRAMING_ERROR;
231 if(!hdlc->do_adapt56){
232 if(hdlc->cbin==fast_abort[hdlc->bit_shift+1]){
233 hdlc->state = HDLC_FAST_IDLE;
238 hdlc->state = HDLC_GET_FLAG_B0;
243 hdlc->shift_reg |= 0x80;
248 switch(hdlc->hdlc_bits1){
252 if(hdlc->data_received){
253 if (hdlc->dstpos < 2) {
254 status = -HDLC_FRAMING_ERROR;
255 } else if (hdlc->crc != 0xf0b8){
257 status = -HDLC_CRC_ERROR;
262 status = hdlc->dstpos;
268 if(!hdlc->do_adapt56){
269 if(hdlc->cbin==fast_flag[hdlc->bit_shift]){
270 hdlc->ffvalue = fast_flag_value[hdlc->bit_shift];
271 hdlc->state = HDLC_FAST_FLAG;
272 hdlc->ffbit_shift = hdlc->bit_shift;
275 hdlc->state = HDLC_GET_DATA;
276 hdlc->data_received = 0;
279 hdlc->state = HDLC_GET_DATA;
280 hdlc->data_received = 0;
288 hdlc->hdlc_bits1 = 0;
297 if(hdlc->data_bits==8){
301 hdlc->data_received = 1;
302 cval = (hdlc->crc^hdlc->shift_reg) & 0xff;
303 hdlc->crc = (hdlc->crc>>8)^crc16_tab[cval];
304 // good byte received
306 dst[hdlc->dstpos++] = hdlc->shift_reg;
309 status = -HDLC_LENGTH_ERROR;
317 if(hdlc->cbin==hdlc->ffvalue){
321 if(hdlc->cbin == 0xff){
322 hdlc->state = HDLC_FAST_IDLE;
324 } else if(hdlc->ffbit_shift==8){
325 hdlc->state = HDLC_GETFLAG_B7;
328 hdlc->shift_reg = fast_abort[hdlc->ffbit_shift-1];
329 hdlc->hdlc_bits1 = hdlc->ffbit_shift-2;
330 if(hdlc->hdlc_bits1<0)hdlc->hdlc_bits1 = 0;
331 hdlc->data_bits = hdlc->ffbit_shift-1;
332 hdlc->state = HDLC_GET_DATA;
333 hdlc->data_received = 0;
346 hdlc_encode - encodes HDLC frames to a transparent bit stream.
348 The bit stream starts with a beginning flag (01111110). After
349 that each byte is added to the bit stream with bit stuffing added
351 When the last byte has been removed from the source buffer, the
352 CRC (2 bytes is added) and the frame terminates with the ending flag.
353 For the dchannel, the idle character (all 1's) is also added at the end.
354 If this function is called with empty source buffer (slen=0), flags or
355 idle character will be generated.
358 slen - source buffer length
359 count - number of bytes removed (encoded) from source buffer
360 dst _ destination buffer
361 dsize - destination buffer size
362 returns - number of encoded bytes in the destination buffer
364 int hdlc_encode(struct hdlc_vars *hdlc, const unsigned char *src,
365 unsigned short slen, int *count,
366 unsigned char *dst, int dsize)
368 static const unsigned char xfast_flag_value[] = {
369 0x7e,0x3f,0x9f,0xcf,0xe7,0xf3,0xf9,0xfc,0x7e
377 if(hdlc->bit_shift==0){
378 if(slen && !hdlc->do_closing){
379 hdlc->shift_reg = *src++;
382 hdlc->do_closing = 1; /* closing sequence, CRC + flag(s) */
385 if(hdlc->state == HDLC_SEND_DATA){
386 if(hdlc->data_received){
387 hdlc->state = HDLC_SEND_CRC1;
390 hdlc->shift_reg = hdlc->crc & 0xff;
391 } else if(!hdlc->do_adapt56){
392 hdlc->state = HDLC_SEND_FAST_FLAG;
394 hdlc->state = HDLC_SENDFLAG_B0;
407 case HDLC_SEND_FAST_FLAG:
408 hdlc->do_closing = 0;
410 *dst++ = hdlc->ffvalue;
415 if(hdlc->bit_shift==8){
416 hdlc->cbin = hdlc->ffvalue>>(8-hdlc->data_bits);
417 hdlc->state = HDLC_SEND_DATA;
419 hdlc->hdlc_bits1 = 0;
420 hdlc->data_received = 1;
423 case HDLC_SENDFLAG_B0:
424 hdlc->do_closing = 0;
427 hdlc->hdlc_bits1 = 0;
428 hdlc->state = HDLC_SENDFLAG_B1A6;
430 case HDLC_SENDFLAG_B1A6:
434 if(++hdlc->hdlc_bits1 == 6)
435 hdlc->state = HDLC_SENDFLAG_B7;
437 case HDLC_SENDFLAG_B7:
441 hdlc->state = HDLC_SENDFLAG_B0;
444 if(hdlc->bit_shift==8){
445 hdlc->state = HDLC_SEND_DATA;
447 hdlc->hdlc_bits1 = 0;
448 hdlc->data_received = 1;
451 case HDLC_SEND_FIRST_FLAG:
452 hdlc->data_received = 1;
453 if(hdlc->data_bits==8){
454 hdlc->state = HDLC_SEND_DATA;
456 hdlc->hdlc_bits1 = 0;
461 if(hdlc->shift_reg & 0x01)
463 hdlc->shift_reg >>= 1;
465 if(hdlc->bit_shift==0){
466 hdlc->state = HDLC_SEND_DATA;
468 hdlc->hdlc_bits1 = 0;
474 if(hdlc->hdlc_bits1 == 5){
475 hdlc->hdlc_bits1 = 0;
478 if(hdlc->bit_shift==8){
481 cval = (hdlc->crc^hdlc->shift_reg) & 0xff;
482 hdlc->crc = (hdlc->crc>>8)^crc16_tab[cval];
484 if(hdlc->shift_reg & 0x01){
487 hdlc->shift_reg >>= 1;
490 hdlc->hdlc_bits1 = 0;
491 hdlc->shift_reg >>= 1;
498 if(hdlc->hdlc_bits1 == 5){
499 hdlc->hdlc_bits1 = 0;
502 if(hdlc->shift_reg & 0x01){
505 hdlc->shift_reg >>= 1;
508 hdlc->hdlc_bits1 = 0;
509 hdlc->shift_reg >>= 1;
512 if(hdlc->bit_shift==0){
513 hdlc->shift_reg = (hdlc->crc >> 8);
514 hdlc->state = HDLC_SEND_CRC2;
521 if(hdlc->hdlc_bits1 == 5){
522 hdlc->hdlc_bits1 = 0;
525 if(hdlc->shift_reg & 0x01){
528 hdlc->shift_reg >>= 1;
531 hdlc->hdlc_bits1 = 0;
532 hdlc->shift_reg >>= 1;
535 if(hdlc->bit_shift==0){
536 hdlc->shift_reg = 0x7e;
537 hdlc->state = HDLC_SEND_CLOSING_FLAG;
541 case HDLC_SEND_CLOSING_FLAG:
544 if(hdlc->hdlc_bits1 == 5){
545 hdlc->hdlc_bits1 = 0;
548 if(hdlc->shift_reg & 0x01){
551 hdlc->shift_reg >>= 1;
553 if(hdlc->bit_shift==0){
554 hdlc->ffvalue = xfast_flag_value[hdlc->data_bits];
556 hdlc->ffvalue = 0x7e;
557 hdlc->state = HDLC_SEND_IDLE1;
558 hdlc->bit_shift = 8-hdlc->data_bits;
559 if(hdlc->bit_shift==0)
560 hdlc->state = HDLC_SEND_FAST_IDLE;
562 if(!hdlc->do_adapt56){
563 hdlc->state = HDLC_SEND_FAST_FLAG;
564 hdlc->data_received = 0;
566 hdlc->state = HDLC_SENDFLAG_B0;
567 hdlc->data_received = 0;
569 // Finished with this frame, send flags
570 if (dsize > 1) dsize = 1;
574 case HDLC_SEND_IDLE1:
575 hdlc->do_closing = 0;
580 if(hdlc->bit_shift==0){
581 hdlc->state = HDLC_SEND_FAST_IDLE;
585 case HDLC_SEND_FAST_IDLE:
586 hdlc->do_closing = 0;
589 if(hdlc->bit_shift == 8){
591 hdlc->state = HDLC_SEND_FIRST_FLAG;
594 hdlc->bit_shift = hdlc->data_bits = 0;
602 if(hdlc->do_adapt56){
603 if(hdlc->data_bits==7){
609 if(hdlc->data_bits==8){