Merge branch 'mv-merge'
[linux-2.6] / drivers / isdn / gigaset / asyncdata.c
1 /*
2  * Common data handling layer for ser_gigaset and usb_gigaset
3  *
4  * Copyright (c) 2005 by Tilman Schmidt <tilman@imap.cc>,
5  *                       Hansjoerg Lipp <hjlipp@web.de>,
6  *                       Stefan Eilers <Eilers.Stefan@epost.de>.
7  *
8  * =====================================================================
9  *      This program is free software; you can redistribute it and/or
10  *      modify it under the terms of the GNU General Public License as
11  *      published by the Free Software Foundation; either version 2 of
12  *      the License, or (at your option) any later version.
13  * =====================================================================
14  * ToDo: ...
15  * =====================================================================
16  * Version: $Id: asyncdata.c,v 1.2.2.7 2005/11/13 23:05:18 hjlipp Exp $
17  * =====================================================================
18  */
19
20 #include "gigaset.h"
21 #include <linux/crc-ccitt.h>
22
23 //#define GIG_M10x_STUFF_VOICE_DATA
24
25 /* check if byte must be stuffed/escaped
26  * I'm not sure which data should be encoded.
27  * Therefore I will go the hard way and decode every value
28  * less than 0x20, the flag sequence and the control escape char.
29  */
30 static inline int muststuff(unsigned char c)
31 {
32         if (c < PPP_TRANS) return 1;
33         if (c == PPP_FLAG) return 1;
34         if (c == PPP_ESCAPE) return 1;
35         /* other possible candidates: */
36         /* 0x91: XON with parity set */
37         /* 0x93: XOFF with parity set */
38         return 0;
39 }
40
41 /* == data input =========================================================== */
42
43 /* process a block of received bytes in command mode (modem response)
44  * Return value:
45  *      number of processed bytes
46  */
47 static inline int cmd_loop(unsigned char c, unsigned char *src, int numbytes,
48                            struct inbuf_t *inbuf)
49 {
50         struct cardstate *cs = inbuf->cs;
51         unsigned cbytes      = cs->cbytes;
52         int inputstate = inbuf->inputstate;
53         int startbytes = numbytes;
54
55         for (;;) {
56                 cs->respdata[cbytes] = c;
57                 if (c == 10 || c == 13) {
58                         dbg(DEBUG_TRANSCMD, "%s: End of Command (%d Bytes)",
59                             __func__, cbytes);
60                         cs->cbytes = cbytes;
61                         gigaset_handle_modem_response(cs); /* can change cs->dle */
62                         cbytes = 0;
63
64                         if (cs->dle &&
65                             !(inputstate & INS_DLE_command)) {
66                                 inputstate &= ~INS_command;
67                                 break;
68                         }
69                 } else {
70                         /* advance in line buffer, checking for overflow */
71                         if (cbytes < MAX_RESP_SIZE - 1)
72                                 cbytes++;
73                         else
74                                 warn("response too large");
75                 }
76
77                 if (!numbytes)
78                         break;
79                 c = *src++;
80                 --numbytes;
81                 if (c == DLE_FLAG &&
82                     (cs->dle || inputstate & INS_DLE_command)) {
83                         inputstate |= INS_DLE_char;
84                         break;
85                 }
86         }
87
88         cs->cbytes = cbytes;
89         inbuf->inputstate = inputstate;
90
91         return startbytes - numbytes;
92 }
93
94 /* process a block of received bytes in lock mode (tty i/f)
95  * Return value:
96  *      number of processed bytes
97  */
98 static inline int lock_loop(unsigned char *src, int numbytes,
99                             struct inbuf_t *inbuf)
100 {
101         struct cardstate *cs = inbuf->cs;
102
103         gigaset_dbg_buffer(DEBUG_LOCKCMD, "received response", numbytes, src, 0);
104         gigaset_if_receive(cs, src, numbytes);
105
106         return numbytes;
107 }
108
109 /* process a block of received bytes in HDLC data mode
110  * Collect HDLC frames, undoing byte stuffing and watching for DLE escapes.
111  * When a frame is complete, check the FCS and pass valid frames to the LL.
112  * If DLE is encountered, return immediately to let the caller handle it.
113  * Return value:
114  *      number of processed bytes
115  *      numbytes (all bytes processed) on error --FIXME
116  */
117 static inline int hdlc_loop(unsigned char c, unsigned char *src, int numbytes,
118                             struct inbuf_t *inbuf)
119 {
120         struct cardstate *cs = inbuf->cs;
121         struct bc_state *bcs = inbuf->bcs;
122         int inputstate;
123         __u16 fcs;
124         struct sk_buff *skb;
125         unsigned char error;
126         struct sk_buff *compskb;
127         int startbytes = numbytes;
128         int l;
129
130         IFNULLRETVAL(bcs, numbytes);
131         inputstate = bcs->inputstate;
132         fcs = bcs->fcs;
133         skb = bcs->skb;
134         IFNULLRETVAL(skb, numbytes);
135
136         if (unlikely(inputstate & INS_byte_stuff)) {
137                 inputstate &= ~INS_byte_stuff;
138                 goto byte_stuff;
139         }
140         for (;;) {
141                 if (unlikely(c == PPP_ESCAPE)) {
142                         if (unlikely(!numbytes)) {
143                                 inputstate |= INS_byte_stuff;
144                                 break;
145                         }
146                         c = *src++;
147                         --numbytes;
148                         if (unlikely(c == DLE_FLAG &&
149                                      (cs->dle ||
150                                       inbuf->inputstate & INS_DLE_command))) {
151                                 inbuf->inputstate |= INS_DLE_char;
152                                 inputstate |= INS_byte_stuff;
153                                 break;
154                         }
155 byte_stuff:
156                         c ^= PPP_TRANS;
157 #ifdef CONFIG_GIGASET_DEBUG
158                         if (unlikely(!muststuff(c)))
159                                 dbg(DEBUG_HDLC,
160                                     "byte stuffed: 0x%02x", c);
161 #endif
162                 } else if (unlikely(c == PPP_FLAG)) {
163                         if (unlikely(inputstate & INS_skip_frame)) {
164                                 if (!(inputstate & INS_have_data)) { /* 7E 7E */
165                                         //dbg(DEBUG_HDLC, "(7e)7e------------------------");
166 #ifdef CONFIG_GIGASET_DEBUG
167                                         ++bcs->emptycount;
168 #endif
169                                 } else
170                                         dbg(DEBUG_HDLC,
171                                             "7e----------------------------");
172
173                                 /* end of frame */
174                                 error = 1;
175                                 gigaset_rcv_error(NULL, cs, bcs);
176                         } else if (!(inputstate & INS_have_data)) { /* 7E 7E */
177                                 //dbg(DEBUG_HDLC, "(7e)7e------------------------");
178 #ifdef CONFIG_GIGASET_DEBUG
179                                 ++bcs->emptycount;
180 #endif
181                                 break;
182                         } else {
183                                 dbg(DEBUG_HDLC,
184                                     "7e----------------------------");
185
186                                 /* end of frame */
187                                 error = 0;
188
189                                 if (unlikely(fcs != PPP_GOODFCS)) {
190                                         err("Packet checksum at %lu failed, "
191                                             "packet is corrupted (%u bytes)!",
192                                             bcs->rcvbytes, skb->len);
193                                         compskb = NULL;
194                                         gigaset_rcv_error(compskb, cs, bcs);
195                                         error = 1;
196                                 } else {
197                                         if (likely((l = skb->len) > 2)) {
198                                                 skb->tail -= 2;
199                                                 skb->len -= 2;
200                                         } else {
201                                                 dev_kfree_skb(skb);
202                                                 skb = NULL;
203                                                 inputstate |= INS_skip_frame;
204                                                 if (l == 1) {
205                                                         err("invalid packet size (1)!");
206                                                         error = 1;
207                                                         gigaset_rcv_error(NULL, cs, bcs);
208                                                 }
209                                         }
210                                         if (likely(!(error ||
211                                                      (inputstate &
212                                                       INS_skip_frame)))) {
213                                                 gigaset_rcv_skb(skb, cs, bcs);
214                                         }
215                                 }
216                         }
217
218                         if (unlikely(error))
219                                 if (skb)
220                                         dev_kfree_skb(skb);
221
222                         fcs = PPP_INITFCS;
223                         inputstate &= ~(INS_have_data | INS_skip_frame);
224                         if (unlikely(bcs->ignore)) {
225                                 inputstate |= INS_skip_frame;
226                                 skb = NULL;
227                         } else if (likely((skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN)) != NULL)) {
228                                 skb_reserve(skb, HW_HDR_LEN);
229                         } else {
230                                 warn("could not allocate new skb");
231                                 inputstate |= INS_skip_frame;
232                         }
233
234                         break;
235 #ifdef CONFIG_GIGASET_DEBUG
236                 } else if (unlikely(muststuff(c))) {
237                         /* Should not happen. Possible after ZDLE=1<CR><LF>. */
238                         dbg(DEBUG_HDLC, "not byte stuffed: 0x%02x", c);
239 #endif
240                 }
241
242                 /* add character */
243
244 #ifdef CONFIG_GIGASET_DEBUG
245                 if (unlikely(!(inputstate & INS_have_data))) {
246                         dbg(DEBUG_HDLC,
247                             "7e (%d x) ================", bcs->emptycount);
248                         bcs->emptycount = 0;
249                 }
250 #endif
251
252                 inputstate |= INS_have_data;
253
254                 if (likely(!(inputstate & INS_skip_frame))) {
255                         if (unlikely(skb->len == SBUFSIZE)) {
256                                 warn("received packet too long");
257                                 dev_kfree_skb_any(skb);
258                                 skb = NULL;
259                                 inputstate |= INS_skip_frame;
260                                 break;
261                         }
262                         *gigaset_skb_put_quick(skb, 1) = c;
263                         /* *__skb_put (skb, 1) = c; */
264                         fcs = crc_ccitt_byte(fcs, c);
265                 }
266
267                 if (unlikely(!numbytes))
268                         break;
269                 c = *src++;
270                 --numbytes;
271                 if (unlikely(c == DLE_FLAG &&
272                              (cs->dle ||
273                               inbuf->inputstate & INS_DLE_command))) {
274                         inbuf->inputstate |= INS_DLE_char;
275                         break;
276                 }
277         }
278         bcs->inputstate = inputstate;
279         bcs->fcs = fcs;
280         bcs->skb = skb;
281         return startbytes - numbytes;
282 }
283
284 /* process a block of received bytes in transparent data mode
285  * Invert bytes, undoing byte stuffing and watching for DLE escapes.
286  * If DLE is encountered, return immediately to let the caller handle it.
287  * Return value:
288  *      number of processed bytes
289  *      numbytes (all bytes processed) on error --FIXME
290  */
291 static inline int iraw_loop(unsigned char c, unsigned char *src, int numbytes,
292                             struct inbuf_t *inbuf)
293 {
294         struct cardstate *cs = inbuf->cs;
295         struct bc_state *bcs = inbuf->bcs;
296         int inputstate;
297         struct sk_buff *skb;
298         int startbytes = numbytes;
299
300         IFNULLRETVAL(bcs, numbytes);
301         inputstate = bcs->inputstate;
302         skb = bcs->skb;
303         IFNULLRETVAL(skb, numbytes);
304
305         for (;;) {
306                 /* add character */
307                 inputstate |= INS_have_data;
308
309                 if (likely(!(inputstate & INS_skip_frame))) {
310                         if (unlikely(skb->len == SBUFSIZE)) {
311                                 //FIXME just pass skb up and allocate a new one
312                                 warn("received packet too long");
313                                 dev_kfree_skb_any(skb);
314                                 skb = NULL;
315                                 inputstate |= INS_skip_frame;
316                                 break;
317                         }
318                         *gigaset_skb_put_quick(skb, 1) = gigaset_invtab[c];
319                 }
320
321                 if (unlikely(!numbytes))
322                         break;
323                 c = *src++;
324                 --numbytes;
325                 if (unlikely(c == DLE_FLAG &&
326                              (cs->dle ||
327                               inbuf->inputstate & INS_DLE_command))) {
328                         inbuf->inputstate |= INS_DLE_char;
329                         break;
330                 }
331         }
332
333         /* pass data up */
334         if (likely(inputstate & INS_have_data)) {
335                 if (likely(!(inputstate & INS_skip_frame))) {
336                         gigaset_rcv_skb(skb, cs, bcs);
337                 }
338                 inputstate &= ~(INS_have_data | INS_skip_frame);
339                 if (unlikely(bcs->ignore)) {
340                         inputstate |= INS_skip_frame;
341                         skb = NULL;
342                 } else if (likely((skb = dev_alloc_skb(SBUFSIZE + HW_HDR_LEN))
343                                   != NULL)) {
344                         skb_reserve(skb, HW_HDR_LEN);
345                 } else {
346                         warn("could not allocate new skb");
347                         inputstate |= INS_skip_frame;
348                 }
349         }
350
351         bcs->inputstate = inputstate;
352         bcs->skb = skb;
353         return startbytes - numbytes;
354 }
355
356 /* process a block of data received from the device
357  */
358 void gigaset_m10x_input(struct inbuf_t *inbuf)
359 {
360         struct cardstate *cs;
361         unsigned tail, head, numbytes;
362         unsigned char *src, c;
363         int procbytes;
364
365         head = atomic_read(&inbuf->head);
366         tail = atomic_read(&inbuf->tail);
367         dbg(DEBUG_INTR, "buffer state: %u -> %u", head, tail);
368
369         if (head != tail) {
370                 cs = inbuf->cs;
371                 src = inbuf->data + head;
372                 numbytes = (head > tail ? RBUFSIZE : tail) - head;
373                 dbg(DEBUG_INTR, "processing %u bytes", numbytes);
374
375                 while (numbytes) {
376                         if (atomic_read(&cs->mstate) == MS_LOCKED) {
377                                 procbytes = lock_loop(src, numbytes, inbuf);
378                                 src += procbytes;
379                                 numbytes -= procbytes;
380                         } else {
381                                 c = *src++;
382                                 --numbytes;
383                                 if (c == DLE_FLAG && (cs->dle ||
384                                     inbuf->inputstate & INS_DLE_command)) {
385                                         if (!(inbuf->inputstate & INS_DLE_char)) {
386                                                 inbuf->inputstate |= INS_DLE_char;
387                                                 goto nextbyte;
388                                         }
389                                         /* <DLE> <DLE> => <DLE> in data stream */
390                                         inbuf->inputstate &= ~INS_DLE_char;
391                                 }
392
393                                 if (!(inbuf->inputstate & INS_DLE_char)) {
394
395                                         /* FIXME Einfach je nach Modus Funktionszeiger in cs setzen [hier+hdlc_loop]?  */
396                                         /* FIXME Spart folgendes "if" und ermoeglicht andere Protokolle */
397                                         if (inbuf->inputstate & INS_command)
398                                                 procbytes = cmd_loop(c, src, numbytes, inbuf);
399                                         else if (inbuf->bcs->proto2 == ISDN_PROTO_L2_HDLC)
400                                                 procbytes = hdlc_loop(c, src, numbytes, inbuf);
401                                         else
402                                                 procbytes = iraw_loop(c, src, numbytes, inbuf);
403
404                                         src += procbytes;
405                                         numbytes -= procbytes;
406                                 } else {  /* DLE-char */
407                                         inbuf->inputstate &= ~INS_DLE_char;
408                                         switch (c) {
409                                         case 'X': /*begin of command*/
410 #ifdef CONFIG_GIGASET_DEBUG
411                                                 if (inbuf->inputstate & INS_command)
412                                                         err("received <DLE> 'X' in command mode");
413 #endif
414                                                 inbuf->inputstate |=
415                                                         INS_command | INS_DLE_command;
416                                                 break;
417                                         case '.': /*end of command*/
418 #ifdef CONFIG_GIGASET_DEBUG
419                                                 if (!(inbuf->inputstate & INS_command))
420                                                         err("received <DLE> '.' in hdlc mode");
421 #endif
422                                                 inbuf->inputstate &= cs->dle ?
423                                                         ~(INS_DLE_command|INS_command)
424                                                         : ~INS_DLE_command;
425                                                 break;
426                                         //case DLE_FLAG: /*DLE_FLAG in data stream*/ /* schon oben behandelt! */
427                                         default:
428                                                 err("received 0x10 0x%02x!", (int) c);
429                                                 /* FIXME: reset driver?? */
430                                         }
431                                 }
432                         }
433 nextbyte:
434                         if (!numbytes) {
435                                 /* end of buffer, check for wrap */
436                                 if (head > tail) {
437                                         head = 0;
438                                         src = inbuf->data;
439                                         numbytes = tail;
440                                 } else {
441                                         head = tail;
442                                         break;
443                                 }
444                         }
445                 }
446
447                 dbg(DEBUG_INTR, "setting head to %u", head);
448                 atomic_set(&inbuf->head, head);
449         }
450 }
451
452
453 /* == data output ========================================================== */
454
455 /* Encoding of a PPP packet into an octet stuffed HDLC frame
456  * with FCS, opening and closing flags.
457  * parameters:
458  *      skb     skb containing original packet (freed upon return)
459  *      head    number of headroom bytes to allocate in result skb
460  *      tail    number of tailroom bytes to allocate in result skb
461  * Return value:
462  *      pointer to newly allocated skb containing the result frame
463  */
464 static struct sk_buff *HDLC_Encode(struct sk_buff *skb, int head, int tail)
465 {
466         struct sk_buff *hdlc_skb;
467         __u16 fcs;
468         unsigned char c;
469         unsigned char *cp;
470         int len;
471         unsigned int stuf_cnt;
472
473         stuf_cnt = 0;
474         fcs = PPP_INITFCS;
475         cp = skb->data;
476         len = skb->len;
477         while (len--) {
478                 if (muststuff(*cp))
479                         stuf_cnt++;
480                 fcs = crc_ccitt_byte(fcs, *cp++);
481         }
482         fcs ^= 0xffff;                 /* complement */
483
484         /* size of new buffer: original size + number of stuffing bytes
485          * + 2 bytes FCS + 2 stuffing bytes for FCS (if needed) + 2 flag bytes
486          */
487         hdlc_skb = dev_alloc_skb(skb->len + stuf_cnt + 6 + tail + head);
488         if (!hdlc_skb) {
489                 err("unable to allocate memory for HDLC encoding!");
490                 dev_kfree_skb(skb);
491                 return NULL;
492         }
493         skb_reserve(hdlc_skb, head);
494
495         /* Copy acknowledge request into new skb */
496         memcpy(hdlc_skb->head, skb->head, 2);
497
498         /* Add flag sequence in front of everything.. */
499         *(skb_put(hdlc_skb, 1)) = PPP_FLAG;
500
501         /* Perform byte stuffing while copying data. */
502         while (skb->len--) {
503                 if (muststuff(*skb->data)) {
504                         *(skb_put(hdlc_skb, 1)) = PPP_ESCAPE;
505                         *(skb_put(hdlc_skb, 1)) = (*skb->data++) ^ PPP_TRANS;
506                 } else
507                         *(skb_put(hdlc_skb, 1)) = *skb->data++;
508         }
509
510         /* Finally add FCS (byte stuffed) and flag sequence */
511         c = (fcs & 0x00ff);      /* least significant byte first */
512         if (muststuff(c)) {
513                 *(skb_put(hdlc_skb, 1)) = PPP_ESCAPE;
514                 c ^= PPP_TRANS;
515         }
516         *(skb_put(hdlc_skb, 1)) = c;
517
518         c = ((fcs >> 8) & 0x00ff);
519         if (muststuff(c)) {
520                 *(skb_put(hdlc_skb, 1)) = PPP_ESCAPE;
521                 c ^= PPP_TRANS;
522         }
523         *(skb_put(hdlc_skb, 1)) = c;
524
525         *(skb_put(hdlc_skb, 1)) = PPP_FLAG;
526
527         dev_kfree_skb(skb);
528         return hdlc_skb;
529 }
530
531 /* Encoding of a raw packet into an octet stuffed bit inverted frame
532  * parameters:
533  *      skb     skb containing original packet (freed upon return)
534  *      head    number of headroom bytes to allocate in result skb
535  *      tail    number of tailroom bytes to allocate in result skb
536  * Return value:
537  *      pointer to newly allocated skb containing the result frame
538  */
539 static struct sk_buff *iraw_encode(struct sk_buff *skb, int head, int tail)
540 {
541         struct sk_buff *iraw_skb;
542         unsigned char c;
543         unsigned char *cp;
544         int len;
545
546         /* worst case: every byte must be stuffed */
547         iraw_skb = dev_alloc_skb(2*skb->len + tail + head);
548         if (!iraw_skb) {
549                 err("unable to allocate memory for HDLC encoding!");
550                 dev_kfree_skb(skb);
551                 return NULL;
552         }
553         skb_reserve(iraw_skb, head);
554
555         cp = skb->data;
556         len = skb->len;
557         while (len--) {
558                 c = gigaset_invtab[*cp++];
559                 if (c == DLE_FLAG)
560                         *(skb_put(iraw_skb, 1)) = c;
561                 *(skb_put(iraw_skb, 1)) = c;
562         }
563         dev_kfree_skb(skb);
564         return iraw_skb;
565 }
566
567 /* gigaset_send_skb
568  * called by common.c to queue an skb for sending
569  * and start transmission if necessary
570  * parameters:
571  *      B Channel control structure
572  *      skb
573  * Return value:
574  *      number of bytes accepted for sending
575  *      (skb->len if ok, 0 if out of buffer space)
576  *      or error code (< 0, eg. -EINVAL)
577  */
578 int gigaset_m10x_send_skb(struct bc_state *bcs, struct sk_buff *skb)
579 {
580         unsigned len;
581
582         IFNULLRETVAL(bcs, -EFAULT);
583         IFNULLRETVAL(skb, -EFAULT);
584         len = skb->len;
585
586         if (bcs->proto2 == ISDN_PROTO_L2_HDLC)
587                 skb = HDLC_Encode(skb, HW_HDR_LEN, 0);
588         else
589                 skb = iraw_encode(skb, HW_HDR_LEN, 0);
590         if (!skb)
591                 return -ENOMEM;
592
593         skb_queue_tail(&bcs->squeue, skb);
594         tasklet_schedule(&bcs->cs->write_tasklet);
595
596         return len;     /* ok so far */
597 }