asyncdata.c

Go to the documentation of this file.

/*
 * Common data handling layer for ser_gigaset and usb_gigaset
 *
 * Copyright (c) 2005 by Tilman Schmidt <[email protected]>,
 *                       Hansjoerg Lipp <[email protected]>,
 *                       Stefan Eilers.
 *
 * =====================================================================
 *  This program is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 * =====================================================================
 */

#include "gigaset.h"
#include <linux/crc-ccitt.h>
#include <linux/bitrev.h>
#include <linux/export.h>

/* check if byte must be stuffed/escaped
 * I'm not sure which data should be encoded.
 * Therefore I will go the hard way and encode every value
 * less than 0x20, the flag sequence and the control escape char.
 */
static inline int muststuff(unsigned char c)
{
    if (c < PPP_TRANS) return 1;
    if (c == PPP_FLAG) return 1;
    if (c == PPP_ESCAPE) return 1;
    /* other possible candidates: */
    /* 0x91: XON with parity set */
    /* 0x93: XOFF with parity set */
    return 0;
}

/* == data input =========================================================== */

/* process a block of received bytes in command mode
 * (mstate != MS_LOCKED && (inputstate & INS_command))
 * Append received bytes to the command response buffer and forward them
 * line by line to the response handler. Exit whenever a mode/state change
 * might have occurred.
 * Note: Received lines may be terminated by CR, LF, or CR LF, which will be
 * removed before passing the line to the response handler.
 * Return value:
 *  number of processed bytes
 */
static unsigned cmd_loop(unsigned numbytes, struct inbuf_t *inbuf)
{
    unsigned char *src = inbuf->data + inbuf->head;
    struct cardstate *cs = inbuf->cs;
    unsigned cbytes = cs->cbytes;
    unsigned procbytes = 0;
    unsigned char c;

    while (procbytes < numbytes) {
        c = *src++;
        procbytes++;

        switch (c) {
        case '\n':
            if (cbytes == 0 && cs->respdata[0] == '\r') {
                /* collapse LF with preceding CR */
                cs->respdata[0] = 0;
                break;
            }
            /* --v-- fall through --v-- */
        case '\r':
            /* end of message line, pass to response handler */
            if (cbytes >= MAX_RESP_SIZE) {
                dev_warn(cs->dev, "response too large (%d)\n",
                     cbytes);
                cbytes = MAX_RESP_SIZE;
            }
            cs->cbytes = cbytes;
            gigaset_dbg_buffer(DEBUG_TRANSCMD, "received response",
                       cbytes, cs->respdata);
            gigaset_handle_modem_response(cs);
            cbytes = 0;

            /* store EOL byte for CRLF collapsing */
            cs->respdata[0] = c;

            /* cs->dle may have changed */
            if (cs->dle && !(inbuf->inputstate & INS_DLE_command))
                inbuf->inputstate &= ~INS_command;

            /* return for reevaluating state */
            goto exit;

        case DLE_FLAG:
            if (inbuf->inputstate & INS_DLE_char) {
                /* quoted DLE: clear quote flag */
                inbuf->inputstate &= ~INS_DLE_char;
            } else if (cs->dle ||
                   (inbuf->inputstate & INS_DLE_command)) {
                /* DLE escape, pass up for handling */
                inbuf->inputstate |= INS_DLE_char;
                goto exit;
            }
            /* quoted or not in DLE mode: treat as regular data */
            /* --v-- fall through --v-- */
        default:
            /* append to line buffer if possible */
            if (cbytes < MAX_RESP_SIZE)
                cs->respdata[cbytes] = c;
            cbytes++;
        }
    }
exit:
    cs->cbytes = cbytes;
    return procbytes;
}

/* process a block of received bytes in lock mode
 * All received bytes are passed unmodified to the tty i/f.
 * Return value:
 *  number of processed bytes
 */
static unsigned lock_loop(unsigned numbytes, struct inbuf_t *inbuf)
{
    unsigned char *src = inbuf->data + inbuf->head;

    gigaset_dbg_buffer(DEBUG_LOCKCMD, "received response", numbytes, src);
    gigaset_if_receive(inbuf->cs, src, numbytes);
    return numbytes;
}

/* process a block of received bytes in HDLC data mode
 * (mstate != MS_LOCKED && !(inputstate & INS_command) && proto2 == L2_HDLC)
 * Collect HDLC frames, undoing byte stuffing and watching for DLE escapes.
 * When a frame is complete, check the FCS and pass valid frames to the LL.
 * If DLE is encountered, return immediately to let the caller handle it.
 * Return value:
 *  number of processed bytes
 */
static unsigned hdlc_loop(unsigned numbytes, struct inbuf_t *inbuf)
{
    struct cardstate *cs = inbuf->cs;
    struct bc_state *bcs = cs->bcs;
    int inputstate = bcs->inputstate;
    __u16 fcs = bcs->rx_fcs;
    struct sk_buff *skb = bcs->rx_skb;
    unsigned char *src = inbuf->data + inbuf->head;
    unsigned procbytes = 0;
    unsigned char c;

    if (inputstate & INS_byte_stuff) {
        if (!numbytes)
            return 0;
        inputstate &= ~INS_byte_stuff;
        goto byte_stuff;
    }

    while (procbytes < numbytes) {
        c = *src++;
        procbytes++;
        if (c == DLE_FLAG) {
            if (inputstate & INS_DLE_char) {
                /* quoted DLE: clear quote flag */
                inputstate &= ~INS_DLE_char;
            } else if (cs->dle || (inputstate & INS_DLE_command)) {
                /* DLE escape, pass up for handling */
                inputstate |= INS_DLE_char;
                break;
            }
        }

        if (c == PPP_ESCAPE) {
            /* byte stuffing indicator: pull in next byte */
            if (procbytes >= numbytes) {
                /* end of buffer, save for later processing */
                inputstate |= INS_byte_stuff;
                break;
            }
byte_stuff:
            c = *src++;
            procbytes++;
            if (c == DLE_FLAG) {
                if (inputstate & INS_DLE_char) {
                    /* quoted DLE: clear quote flag */
                    inputstate &= ~INS_DLE_char;
                } else if (cs->dle ||
                       (inputstate & INS_DLE_command)) {
                    /* DLE escape, pass up for handling */
                    inputstate |=
                        INS_DLE_char | INS_byte_stuff;
                    break;
                }
            }
            c ^= PPP_TRANS;
#ifdef CONFIG_GIGASET_DEBUG
            if (!muststuff(c))
                gig_dbg(DEBUG_HDLC, "byte stuffed: 0x%02x", c);
#endif
        } else if (c == PPP_FLAG) {
            /* end of frame: process content if any */
            if (inputstate & INS_have_data) {
                gig_dbg(DEBUG_HDLC,
                    "7e----------------------------");

                /* check and pass received frame */
                if (!skb) {
                    /* skipped frame */
                    gigaset_isdn_rcv_err(bcs);
                } else if (skb->len < 2) {
                    /* frame too short for FCS */
                    dev_warn(cs->dev,
                         "short frame (%d)\n",
                         skb->len);
                    gigaset_isdn_rcv_err(bcs);
                    dev_kfree_skb_any(skb);
                } else if (fcs != PPP_GOODFCS) {
                    /* frame check error */
                    dev_err(cs->dev,
                        "Checksum failed, %u bytes corrupted!\n",
                        skb->len);
                    gigaset_isdn_rcv_err(bcs);
                    dev_kfree_skb_any(skb);
                } else {
                    /* good frame */
                    __skb_trim(skb, skb->len - 2);
                    gigaset_skb_rcvd(bcs, skb);
                }

                /* prepare reception of next frame */
                inputstate &= ~INS_have_data;
                skb = gigaset_new_rx_skb(bcs);
            } else {
                /* empty frame (7E 7E) */
#ifdef CONFIG_GIGASET_DEBUG
                ++bcs->emptycount;
#endif
                if (!skb) {
                    /* skipped (?) */
                    gigaset_isdn_rcv_err(bcs);
                    skb = gigaset_new_rx_skb(bcs);
                }
            }

            fcs = PPP_INITFCS;
            continue;
#ifdef CONFIG_GIGASET_DEBUG
        } else if (muststuff(c)) {
            /* Should not happen. Possible after ZDLE=1<CR><LF>. */
            gig_dbg(DEBUG_HDLC, "not byte stuffed: 0x%02x", c);
#endif
        }

        /* regular data byte, append to skb */
#ifdef CONFIG_GIGASET_DEBUG
        if (!(inputstate & INS_have_data)) {
            gig_dbg(DEBUG_HDLC, "7e (%d x) ================",
                bcs->emptycount);
            bcs->emptycount = 0;
        }
#endif
        inputstate |= INS_have_data;
        if (skb) {
            if (skb->len >= bcs->rx_bufsize) {
                dev_warn(cs->dev, "received packet too long\n");
                dev_kfree_skb_any(skb);
                /* skip remainder of packet */
                bcs->rx_skb = skb = NULL;
            } else {
                *__skb_put(skb, 1) = c;
                fcs = crc_ccitt_byte(fcs, c);
            }
        }
    }

    bcs->inputstate = inputstate;
    bcs->rx_fcs = fcs;
    return procbytes;
}

/* process a block of received bytes in transparent data mode
 * (mstate != MS_LOCKED && !(inputstate & INS_command) && proto2 != L2_HDLC)
 * Invert bytes, undoing byte stuffing and watching for DLE escapes.
 * If DLE is encountered, return immediately to let the caller handle it.
 * Return value:
 *  number of processed bytes
 */
static unsigned iraw_loop(unsigned numbytes, struct inbuf_t *inbuf)
{
    struct cardstate *cs = inbuf->cs;
    struct bc_state *bcs = cs->bcs;
    int inputstate = bcs->inputstate;
    struct sk_buff *skb = bcs->rx_skb;
    unsigned char *src = inbuf->data + inbuf->head;
    unsigned procbytes = 0;
    unsigned char c;

    if (!skb) {
        /* skip this block */
        gigaset_new_rx_skb(bcs);
        return numbytes;
    }

    while (procbytes < numbytes && skb->len < bcs->rx_bufsize) {
        c = *src++;
        procbytes++;

        if (c == DLE_FLAG) {
            if (inputstate & INS_DLE_char) {
                /* quoted DLE: clear quote flag */
                inputstate &= ~INS_DLE_char;
            } else if (cs->dle || (inputstate & INS_DLE_command)) {
                /* DLE escape, pass up for handling */
                inputstate |= INS_DLE_char;
                break;
            }
        }

        /* regular data byte: append to current skb */
        inputstate |= INS_have_data;
        *__skb_put(skb, 1) = bitrev8(c);
    }

    /* pass data up */
    if (inputstate & INS_have_data) {
        gigaset_skb_rcvd(bcs, skb);
        inputstate &= ~INS_have_data;
        gigaset_new_rx_skb(bcs);
    }

    bcs->inputstate = inputstate;
    return procbytes;
}

/* process DLE escapes
 * Called whenever a DLE sequence might be encountered in the input stream.
 * Either processes the entire DLE sequence or, if that isn't possible,
 * notes the fact that an initial DLE has been received in the INS_DLE_char
 * inputstate flag and resumes processing of the sequence on the next call.
 */
static void handle_dle(struct inbuf_t *inbuf)
{
    struct cardstate *cs = inbuf->cs;

    if (cs->mstate == MS_LOCKED)
        return;     /* no DLE processing in lock mode */

    if (!(inbuf->inputstate & INS_DLE_char)) {
        /* no DLE pending */
        if (inbuf->data[inbuf->head] == DLE_FLAG &&
            (cs->dle || inbuf->inputstate & INS_DLE_command)) {
            /* start of DLE sequence */
            inbuf->head++;
            if (inbuf->head == inbuf->tail ||
                inbuf->head == RBUFSIZE) {
                /* end of buffer, save for later processing */
                inbuf->inputstate |= INS_DLE_char;
                return;
            }
        } else {
            /* regular data byte */
            return;
        }
    }

    /* consume pending DLE */
    inbuf->inputstate &= ~INS_DLE_char;

    switch (inbuf->data[inbuf->head]) {
    case 'X':   /* begin of event message */
        if (inbuf->inputstate & INS_command)
            dev_notice(cs->dev,
                   "received <DLE>X in command mode\n");
        inbuf->inputstate |= INS_command | INS_DLE_command;
        inbuf->head++;  /* byte consumed */
        break;
    case '.':   /* end of event message */
        if (!(inbuf->inputstate & INS_DLE_command))
            dev_notice(cs->dev,
                   "received <DLE>. without <DLE>X\n");
        inbuf->inputstate &= ~INS_DLE_command;
        /* return to data mode if in DLE mode */
        if (cs->dle)
            inbuf->inputstate &= ~INS_command;
        inbuf->head++;  /* byte consumed */
        break;
    case DLE_FLAG:  /* DLE in data stream */
        /* mark as quoted */
        inbuf->inputstate |= INS_DLE_char;
        if (!(cs->dle || inbuf->inputstate & INS_DLE_command))
            dev_notice(cs->dev,
                   "received <DLE><DLE> not in DLE mode\n");
        break;  /* quoted byte left in buffer */
    default:
        dev_notice(cs->dev, "received <DLE><%02x>\n",
               inbuf->data[inbuf->head]);
        /* quoted byte left in buffer */
    }
}

void gigaset_m10x_input(struct inbuf_t *inbuf)
{
    struct cardstate *cs = inbuf->cs;
    unsigned numbytes, procbytes;

    gig_dbg(DEBUG_INTR, "buffer state: %u -> %u", inbuf->head, inbuf->tail);

    while (inbuf->head != inbuf->tail) {
        /* check for DLE escape */
        handle_dle(inbuf);

        /* process a contiguous block of bytes */
        numbytes = (inbuf->head > inbuf->tail ?
                RBUFSIZE : inbuf->tail) - inbuf->head;
        gig_dbg(DEBUG_INTR, "processing %u bytes", numbytes);
        /*
         * numbytes may be 0 if handle_dle() ate the last byte.
         * This does no harm, *_loop() will just return 0 immediately.
         */

        if (cs->mstate == MS_LOCKED)
            procbytes = lock_loop(numbytes, inbuf);
        else if (inbuf->inputstate & INS_command)
            procbytes = cmd_loop(numbytes, inbuf);
        else if (cs->bcs->proto2 == L2_HDLC)
            procbytes = hdlc_loop(numbytes, inbuf);
        else
            procbytes = iraw_loop(numbytes, inbuf);
        inbuf->head += procbytes;

        /* check for buffer wraparound */
        if (inbuf->head >= RBUFSIZE)
            inbuf->head = 0;

        gig_dbg(DEBUG_INTR, "head set to %u", inbuf->head);
    }
}
EXPORT_SYMBOL_GPL(gigaset_m10x_input);


/* == data output ========================================================== */

/*
 * Encode a data packet into an octet stuffed HDLC frame with FCS,
 * opening and closing flags, preserving headroom data.
 * parameters:
 *  skb     skb containing original packet (freed upon return)
 * Return value:
 *  pointer to newly allocated skb containing the result frame
 *  and the original link layer header, NULL on error
 */
static struct sk_buff *HDLC_Encode(struct sk_buff *skb)
{
    struct sk_buff *hdlc_skb;
    __u16 fcs;
    unsigned char c;
    unsigned char *cp;
    int len;
    unsigned int stuf_cnt;

    stuf_cnt = 0;
    fcs = PPP_INITFCS;
    cp = skb->data;
    len = skb->len;
    while (len--) {
        if (muststuff(*cp))
            stuf_cnt++;
        fcs = crc_ccitt_byte(fcs, *cp++);
    }
    fcs ^= 0xffff;          /* complement */

    /* size of new buffer: original size + number of stuffing bytes
     * + 2 bytes FCS + 2 stuffing bytes for FCS (if needed) + 2 flag bytes
     * + room for link layer header
     */
    hdlc_skb = dev_alloc_skb(skb->len + stuf_cnt + 6 + skb->mac_len);
    if (!hdlc_skb) {
        dev_kfree_skb_any(skb);
        return NULL;
    }

    /* Copy link layer header into new skb */
    skb_reset_mac_header(hdlc_skb);
    skb_reserve(hdlc_skb, skb->mac_len);
    memcpy(skb_mac_header(hdlc_skb), skb_mac_header(skb), skb->mac_len);
    hdlc_skb->mac_len = skb->mac_len;

    /* Add flag sequence in front of everything.. */
    *(skb_put(hdlc_skb, 1)) = PPP_FLAG;

    /* Perform byte stuffing while copying data. */
    while (skb->len--) {
        if (muststuff(*skb->data)) {
            *(skb_put(hdlc_skb, 1)) = PPP_ESCAPE;
            *(skb_put(hdlc_skb, 1)) = (*skb->data++) ^ PPP_TRANS;
        } else
            *(skb_put(hdlc_skb, 1)) = *skb->data++;
    }

    /* Finally add FCS (byte stuffed) and flag sequence */
    c = (fcs & 0x00ff); /* least significant byte first */
    if (muststuff(c)) {
        *(skb_put(hdlc_skb, 1)) = PPP_ESCAPE;
        c ^= PPP_TRANS;
    }
    *(skb_put(hdlc_skb, 1)) = c;

    c = ((fcs >> 8) & 0x00ff);
    if (muststuff(c)) {
        *(skb_put(hdlc_skb, 1)) = PPP_ESCAPE;
        c ^= PPP_TRANS;
    }
    *(skb_put(hdlc_skb, 1)) = c;

    *(skb_put(hdlc_skb, 1)) = PPP_FLAG;

    dev_kfree_skb_any(skb);
    return hdlc_skb;
}

/*
 * Encode a data packet into an octet stuffed raw bit inverted frame,
 * preserving headroom data.
 * parameters:
 *  skb     skb containing original packet (freed upon return)
 * Return value:
 *  pointer to newly allocated skb containing the result frame
 *  and the original link layer header, NULL on error
 */
static struct sk_buff *iraw_encode(struct sk_buff *skb)
{
    struct sk_buff *iraw_skb;
    unsigned char c;
    unsigned char *cp;
    int len;

    /* size of new buffer (worst case = every byte must be stuffed):
     * 2 * original size + room for link layer header
     */
    iraw_skb = dev_alloc_skb(2 * skb->len + skb->mac_len);
    if (!iraw_skb) {
        dev_kfree_skb_any(skb);
        return NULL;
    }

    /* copy link layer header into new skb */
    skb_reset_mac_header(iraw_skb);
    skb_reserve(iraw_skb, skb->mac_len);
    memcpy(skb_mac_header(iraw_skb), skb_mac_header(skb), skb->mac_len);
    iraw_skb->mac_len = skb->mac_len;

    /* copy and stuff data */
    cp = skb->data;
    len = skb->len;
    while (len--) {
        c = bitrev8(*cp++);
        if (c == DLE_FLAG)
            *(skb_put(iraw_skb, 1)) = c;
        *(skb_put(iraw_skb, 1)) = c;
    }
    dev_kfree_skb_any(skb);
    return iraw_skb;
}

int gigaset_m10x_send_skb(struct bc_state *bcs, struct sk_buff *skb)
{
    struct cardstate *cs = bcs->cs;
    unsigned len = skb->len;
    unsigned long flags;

    if (bcs->proto2 == L2_HDLC)
        skb = HDLC_Encode(skb);
    else
        skb = iraw_encode(skb);
    if (!skb) {
        dev_err(cs->dev,
            "unable to allocate memory for encoding!\n");
        return -ENOMEM;
    }

    skb_queue_tail(&bcs->squeue, skb);
    spin_lock_irqsave(&cs->lock, flags);
    if (cs->connected)
        tasklet_schedule(&cs->write_tasklet);
    spin_unlock_irqrestore(&cs->lock, flags);

    return len; /* ok so far */
}
EXPORT_SYMBOL_GPL(gigaset_m10x_send_skb);