2 * Common data handling layer for ser_gigaset and usb_gigaset
4 * Copyright (c) 2005 by Tilman Schmidt <tilman@imap.cc>,
5 * Hansjoerg Lipp <hjlipp@web.de>,
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 * =====================================================================
17 #include <linux/crc-ccitt.h>
18 #include <linux/bitrev.h>
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 encode every value
23 * less than 0x20, the flag sequence and the control escape char.
25 static inline int muststuff(unsigned char c)
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 */
36 /* == data input =========================================================== */
38 /* process a block of received bytes in command mode
39 * (mstate != MS_LOCKED && (inputstate & INS_command))
40 * Append received bytes to the command response buffer and forward them
41 * line by line to the response handler. Exit whenever a mode/state change
42 * might have occurred.
43 * Note: Received lines may be terminated by CR, LF, or CR LF, which will be
44 * removed before passing the line to the response handler.
46 * number of processed bytes
48 static unsigned cmd_loop(unsigned numbytes, struct inbuf_t *inbuf)
50 unsigned char *src = inbuf->data + inbuf->head;
51 struct cardstate *cs = inbuf->cs;
52 unsigned cbytes = cs->cbytes;
53 unsigned procbytes = 0;
56 while (procbytes < numbytes) {
62 if (cbytes == 0 && cs->respdata[0] == '\r') {
63 /* collapse LF with preceding CR */
67 /* --v-- fall through --v-- */
69 /* end of message line, pass to response handler */
70 if (cbytes >= MAX_RESP_SIZE) {
71 dev_warn(cs->dev, "response too large (%d)\n",
73 cbytes = MAX_RESP_SIZE;
76 gigaset_dbg_buffer(DEBUG_TRANSCMD, "received response",
77 cbytes, cs->respdata);
78 gigaset_handle_modem_response(cs);
81 /* store EOL byte for CRLF collapsing */
84 /* cs->dle may have changed */
85 if (cs->dle && !(inbuf->inputstate & INS_DLE_command))
86 inbuf->inputstate &= ~INS_command;
88 /* return for reevaluating state */
92 if (inbuf->inputstate & INS_DLE_char) {
93 /* quoted DLE: clear quote flag */
94 inbuf->inputstate &= ~INS_DLE_char;
96 (inbuf->inputstate & INS_DLE_command)) {
97 /* DLE escape, pass up for handling */
98 inbuf->inputstate |= INS_DLE_char;
101 /* quoted or not in DLE mode: treat as regular data */
102 /* --v-- fall through --v-- */
104 /* append to line buffer if possible */
105 if (cbytes < MAX_RESP_SIZE)
106 cs->respdata[cbytes] = c;
115 /* process a block of received bytes in lock mode
116 * All received bytes are passed unmodified to the tty i/f.
118 * number of processed bytes
120 static unsigned lock_loop(unsigned numbytes, struct inbuf_t *inbuf)
122 unsigned char *src = inbuf->data + inbuf->head;
124 gigaset_dbg_buffer(DEBUG_LOCKCMD, "received response", numbytes, src);
125 gigaset_if_receive(inbuf->cs, src, numbytes);
129 /* set up next receive skb for data mode
131 static void new_rcv_skb(struct bc_state *bcs)
133 struct cardstate *cs = bcs->cs;
134 unsigned short hw_hdr_len = cs->hw_hdr_len;
141 bcs->skb = dev_alloc_skb(SBUFSIZE + hw_hdr_len);
142 if (bcs->skb == NULL) {
143 dev_warn(cs->dev, "could not allocate new skb\n");
146 skb_reserve(bcs->skb, hw_hdr_len);
149 /* process a block of received bytes in HDLC data mode
150 * (mstate != MS_LOCKED && !(inputstate & INS_command) && proto2 == L2_HDLC)
151 * Collect HDLC frames, undoing byte stuffing and watching for DLE escapes.
152 * When a frame is complete, check the FCS and pass valid frames to the LL.
153 * If DLE is encountered, return immediately to let the caller handle it.
155 * number of processed bytes
157 static unsigned hdlc_loop(unsigned numbytes, struct inbuf_t *inbuf)
159 struct cardstate *cs = inbuf->cs;
160 struct bc_state *bcs = cs->bcs;
161 int inputstate = bcs->inputstate;
162 __u16 fcs = bcs->fcs;
163 struct sk_buff *skb = bcs->skb;
164 unsigned char *src = inbuf->data + inbuf->head;
165 unsigned procbytes = 0;
168 if (inputstate & INS_byte_stuff) {
171 inputstate &= ~INS_byte_stuff;
175 while (procbytes < numbytes) {
179 if (inputstate & INS_DLE_char) {
180 /* quoted DLE: clear quote flag */
181 inputstate &= ~INS_DLE_char;
182 } else if (cs->dle || (inputstate & INS_DLE_command)) {
183 /* DLE escape, pass up for handling */
184 inputstate |= INS_DLE_char;
189 if (c == PPP_ESCAPE) {
190 /* byte stuffing indicator: pull in next byte */
191 if (procbytes >= numbytes) {
192 /* end of buffer, save for later processing */
193 inputstate |= INS_byte_stuff;
200 if (inputstate & INS_DLE_char) {
201 /* quoted DLE: clear quote flag */
202 inputstate &= ~INS_DLE_char;
203 } else if (cs->dle ||
204 (inputstate & INS_DLE_command)) {
205 /* DLE escape, pass up for handling */
207 INS_DLE_char | INS_byte_stuff;
212 #ifdef CONFIG_GIGASET_DEBUG
214 gig_dbg(DEBUG_HDLC, "byte stuffed: 0x%02x", c);
216 } else if (c == PPP_FLAG) {
217 /* end of frame: process content if any */
218 if (inputstate & INS_have_data) {
220 "7e----------------------------");
222 /* check and pass received frame */
225 gigaset_isdn_rcv_err(bcs);
226 } else if (skb->len < 2) {
227 /* frame too short for FCS */
229 "short frame (%d)\n",
231 gigaset_isdn_rcv_err(bcs);
232 dev_kfree_skb_any(skb);
233 } else if (fcs != PPP_GOODFCS) {
234 /* frame check error */
236 "Checksum failed, %u bytes corrupted!\n",
238 gigaset_isdn_rcv_err(bcs);
239 dev_kfree_skb_any(skb);
242 __skb_trim(skb, skb->len - 2);
243 gigaset_skb_rcvd(bcs, skb);
246 /* prepare reception of next frame */
247 inputstate &= ~INS_have_data;
251 /* empty frame (7E 7E) */
252 #ifdef CONFIG_GIGASET_DEBUG
257 gigaset_isdn_rcv_err(bcs);
265 #ifdef CONFIG_GIGASET_DEBUG
266 } else if (muststuff(c)) {
267 /* Should not happen. Possible after ZDLE=1<CR><LF>. */
268 gig_dbg(DEBUG_HDLC, "not byte stuffed: 0x%02x", c);
272 /* regular data byte, append to skb */
273 #ifdef CONFIG_GIGASET_DEBUG
274 if (!(inputstate & INS_have_data)) {
275 gig_dbg(DEBUG_HDLC, "7e (%d x) ================",
280 inputstate |= INS_have_data;
282 if (skb->len == SBUFSIZE) {
283 dev_warn(cs->dev, "received packet too long\n");
284 dev_kfree_skb_any(skb);
285 /* skip remainder of packet */
286 bcs->skb = skb = NULL;
288 *__skb_put(skb, 1) = c;
289 fcs = crc_ccitt_byte(fcs, c);
294 bcs->inputstate = inputstate;
299 /* process a block of received bytes in transparent data mode
300 * (mstate != MS_LOCKED && !(inputstate & INS_command) && proto2 != L2_HDLC)
301 * Invert bytes, undoing byte stuffing and watching for DLE escapes.
302 * If DLE is encountered, return immediately to let the caller handle it.
304 * number of processed bytes
306 static unsigned iraw_loop(unsigned numbytes, struct inbuf_t *inbuf)
308 struct cardstate *cs = inbuf->cs;
309 struct bc_state *bcs = cs->bcs;
310 int inputstate = bcs->inputstate;
311 struct sk_buff *skb = bcs->skb;
312 unsigned char *src = inbuf->data + inbuf->head;
313 unsigned procbytes = 0;
317 /* skip this block */
322 while (procbytes < numbytes && skb->len < SBUFSIZE) {
327 if (inputstate & INS_DLE_char) {
328 /* quoted DLE: clear quote flag */
329 inputstate &= ~INS_DLE_char;
330 } else if (cs->dle || (inputstate & INS_DLE_command)) {
331 /* DLE escape, pass up for handling */
332 inputstate |= INS_DLE_char;
337 /* regular data byte: append to current skb */
338 inputstate |= INS_have_data;
339 *__skb_put(skb, 1) = bitrev8(c);
343 if (inputstate & INS_have_data) {
344 gigaset_skb_rcvd(bcs, skb);
345 inputstate &= ~INS_have_data;
349 bcs->inputstate = inputstate;
353 /* process DLE escapes
354 * Called whenever a DLE sequence might be encountered in the input stream.
355 * Either processes the entire DLE sequence or, if that isn't possible,
356 * notes the fact that an initial DLE has been received in the INS_DLE_char
357 * inputstate flag and resumes processing of the sequence on the next call.
359 static void handle_dle(struct inbuf_t *inbuf)
361 struct cardstate *cs = inbuf->cs;
363 if (cs->mstate == MS_LOCKED)
364 return; /* no DLE processing in lock mode */
366 if (!(inbuf->inputstate & INS_DLE_char)) {
368 if (inbuf->data[inbuf->head] == DLE_FLAG &&
369 (cs->dle || inbuf->inputstate & INS_DLE_command)) {
370 /* start of DLE sequence */
372 if (inbuf->head == inbuf->tail ||
373 inbuf->head == RBUFSIZE) {
374 /* end of buffer, save for later processing */
375 inbuf->inputstate |= INS_DLE_char;
379 /* regular data byte */
384 /* consume pending DLE */
385 inbuf->inputstate &= ~INS_DLE_char;
387 switch (inbuf->data[inbuf->head]) {
388 case 'X': /* begin of event message */
389 if (inbuf->inputstate & INS_command)
391 "received <DLE>X in command mode\n");
392 inbuf->inputstate |= INS_command | INS_DLE_command;
393 inbuf->head++; /* byte consumed */
395 case '.': /* end of event message */
396 if (!(inbuf->inputstate & INS_DLE_command))
398 "received <DLE>. without <DLE>X\n");
399 inbuf->inputstate &= ~INS_DLE_command;
400 /* return to data mode if in DLE mode */
402 inbuf->inputstate &= ~INS_command;
403 inbuf->head++; /* byte consumed */
405 case DLE_FLAG: /* DLE in data stream */
407 inbuf->inputstate |= INS_DLE_char;
408 if (!(cs->dle || inbuf->inputstate & INS_DLE_command))
410 "received <DLE><DLE> not in DLE mode\n");
411 break; /* quoted byte left in buffer */
413 dev_notice(cs->dev, "received <DLE><%02x>\n",
414 inbuf->data[inbuf->head]);
415 /* quoted byte left in buffer */
420 * gigaset_m10x_input() - process a block of data received from the device
421 * @inbuf: received data and device descriptor structure.
423 * Called by hardware module {ser,usb}_gigaset with a block of received
424 * bytes. Separates the bytes received over the serial data channel into
425 * user data and command replies (locked/unlocked) according to the
426 * current state of the interface.
428 void gigaset_m10x_input(struct inbuf_t *inbuf)
430 struct cardstate *cs = inbuf->cs;
431 unsigned numbytes, procbytes;
433 gig_dbg(DEBUG_INTR, "buffer state: %u -> %u", inbuf->head, inbuf->tail);
435 while (inbuf->head != inbuf->tail) {
436 /* check for DLE escape */
439 /* process a contiguous block of bytes */
440 numbytes = (inbuf->head > inbuf->tail ?
441 RBUFSIZE : inbuf->tail) - inbuf->head;
442 gig_dbg(DEBUG_INTR, "processing %u bytes", numbytes);
444 * numbytes may be 0 if handle_dle() ate the last byte.
445 * This does no harm, *_loop() will just return 0 immediately.
448 if (cs->mstate == MS_LOCKED)
449 procbytes = lock_loop(numbytes, inbuf);
450 else if (inbuf->inputstate & INS_command)
451 procbytes = cmd_loop(numbytes, inbuf);
452 else if (cs->bcs->proto2 == L2_HDLC)
453 procbytes = hdlc_loop(numbytes, inbuf);
455 procbytes = iraw_loop(numbytes, inbuf);
456 inbuf->head += procbytes;
458 /* check for buffer wraparound */
459 if (inbuf->head >= RBUFSIZE)
462 gig_dbg(DEBUG_INTR, "head set to %u", inbuf->head);
465 EXPORT_SYMBOL_GPL(gigaset_m10x_input);
468 /* == data output ========================================================== */
471 * Encode a data packet into an octet stuffed HDLC frame with FCS,
472 * opening and closing flags, preserving headroom data.
474 * skb skb containing original packet (freed upon return)
476 * pointer to newly allocated skb containing the result frame
477 * and the original link layer header, NULL on error
479 static struct sk_buff *HDLC_Encode(struct sk_buff *skb)
481 struct sk_buff *hdlc_skb;
486 unsigned int stuf_cnt;
495 fcs = crc_ccitt_byte(fcs, *cp++);
497 fcs ^= 0xffff; /* complement */
499 /* size of new buffer: original size + number of stuffing bytes
500 * + 2 bytes FCS + 2 stuffing bytes for FCS (if needed) + 2 flag bytes
501 * + room for link layer header
503 hdlc_skb = dev_alloc_skb(skb->len + stuf_cnt + 6 + skb->mac_len);
505 dev_kfree_skb_any(skb);
509 /* Copy link layer header into new skb */
510 skb_reset_mac_header(hdlc_skb);
511 skb_reserve(hdlc_skb, skb->mac_len);
512 memcpy(skb_mac_header(hdlc_skb), skb_mac_header(skb), skb->mac_len);
513 hdlc_skb->mac_len = skb->mac_len;
515 /* Add flag sequence in front of everything.. */
516 *(skb_put(hdlc_skb, 1)) = PPP_FLAG;
518 /* Perform byte stuffing while copying data. */
520 if (muststuff(*skb->data)) {
521 *(skb_put(hdlc_skb, 1)) = PPP_ESCAPE;
522 *(skb_put(hdlc_skb, 1)) = (*skb->data++) ^ PPP_TRANS;
524 *(skb_put(hdlc_skb, 1)) = *skb->data++;
527 /* Finally add FCS (byte stuffed) and flag sequence */
528 c = (fcs & 0x00ff); /* least significant byte first */
530 *(skb_put(hdlc_skb, 1)) = PPP_ESCAPE;
533 *(skb_put(hdlc_skb, 1)) = c;
535 c = ((fcs >> 8) & 0x00ff);
537 *(skb_put(hdlc_skb, 1)) = PPP_ESCAPE;
540 *(skb_put(hdlc_skb, 1)) = c;
542 *(skb_put(hdlc_skb, 1)) = PPP_FLAG;
544 dev_kfree_skb_any(skb);
549 * Encode a data packet into an octet stuffed raw bit inverted frame,
550 * preserving headroom data.
552 * skb skb containing original packet (freed upon return)
554 * pointer to newly allocated skb containing the result frame
555 * and the original link layer header, NULL on error
557 static struct sk_buff *iraw_encode(struct sk_buff *skb)
559 struct sk_buff *iraw_skb;
564 /* size of new buffer (worst case = every byte must be stuffed):
565 * 2 * original size + room for link layer header
567 iraw_skb = dev_alloc_skb(2*skb->len + skb->mac_len);
569 dev_kfree_skb_any(skb);
573 /* copy link layer header into new skb */
574 skb_reset_mac_header(iraw_skb);
575 skb_reserve(iraw_skb, skb->mac_len);
576 memcpy(skb_mac_header(iraw_skb), skb_mac_header(skb), skb->mac_len);
577 iraw_skb->mac_len = skb->mac_len;
579 /* copy and stuff data */
585 *(skb_put(iraw_skb, 1)) = c;
586 *(skb_put(iraw_skb, 1)) = c;
588 dev_kfree_skb_any(skb);
593 * gigaset_m10x_send_skb() - queue an skb for sending
594 * @bcs: B channel descriptor structure.
595 * @skb: data to send.
597 * Called by LL to encode and queue an skb for sending, and start
598 * transmission if necessary.
599 * Once the payload data has been transmitted completely, gigaset_skb_sent()
600 * will be called with the skb's link layer header preserved.
603 * number of bytes accepted for sending (skb->len) if ok,
604 * error code < 0 (eg. -ENOMEM) on error
606 int gigaset_m10x_send_skb(struct bc_state *bcs, struct sk_buff *skb)
608 struct cardstate *cs = bcs->cs;
609 unsigned len = skb->len;
612 if (bcs->proto2 == L2_HDLC)
613 skb = HDLC_Encode(skb);
615 skb = iraw_encode(skb);
618 "unable to allocate memory for encoding!\n");
622 skb_queue_tail(&bcs->squeue, skb);
623 spin_lock_irqsave(&cs->lock, flags);
625 tasklet_schedule(&cs->write_tasklet);
626 spin_unlock_irqrestore(&cs->lock, flags);
628 return len; /* ok so far */
630 EXPORT_SYMBOL_GPL(gigaset_m10x_send_skb);