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