/*

* n_gsm.c GSM 0710 tty multiplexor

* Copyright (c) 2009/10 Intel Corporation

*

* This program is free software; you can redistribute it and/or modify

* it under the terms of the GNU General Public License version 2 as

* published by the Free Software Foundation.

*

* This program is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

* GNU General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*

* * THIS IS A DEVELOPMENT SNAPSHOT IT IS NOT A FINAL RELEASE *

*

* TO DO:

* Mostly done: ioctls for setting modes/timing

* Partly done: hooks so you can pull off frames to non tty devs

* Restart DLCI 0 when it closes ?

* Test basic encoding

* Improve the tx engine

* Resolve tx side locking by adding a queue_head and routing

* all control traffic via it

* General tidy/document

* Review the locking/move to refcounts more (mux now moved to an

* alloc/free model ready)

* Use newest tty open/close port helpers and install hooks

* What to do about power functions ?

* Termios setting and negotiation

* Do we need a 'which mux are you' ioctl to correlate mux and tty sets

*

*/

#include <linux/types.h>

#include <linux/major.h>

#include <linux/errno.h>

#include <linux/signal.h>

#include <linux/fcntl.h>

#include <linux/sched.h>

#include <linux/interrupt.h>

#include <linux/tty.h>

#include <linux/ctype.h>

#include <linux/mm.h>

#include <linux/string.h>

#include <linux/slab.h>

#include <linux/poll.h>

#include <linux/bitops.h>

#include <linux/file.h>

#include <linux/uaccess.h>

#include <linux/module.h>

#include <linux/timer.h>

#include <linux/tty_flip.h>

#include <linux/tty_driver.h>

#include <linux/serial.h>

#include <linux/kfifo.h>

#include <linux/skbuff.h>

#include <net/arp.h>

#include <linux/ip.h>

#include <linux/netdevice.h>

#include <linux/etherdevice.h>

#include <linux/gsmmux.h>

static int debug;

module_param(debug, int, 0600);

#define T1 (HZ/10)

#define T2 (HZ/3)

#define N2 3

/* Use long timers for testing at low speed with debug on */

#ifdef DEBUG_TIMING

#define T1 HZ

#define T2 (2 * HZ)

#endif

/*

* Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte

* limits so this is plenty

*/

#define MAX_MRU 1500

#define MAX_MTU 1500

#define GSM_NET_TX_TIMEOUT (HZ*10)

/**

* struct gsm_mux_net - network interface

* @struct gsm_dlci* dlci

* @struct net_device_stats stats;

*

* Created when net interface is initialized.

**/

struct gsm_mux_net {

struct kref ref;

struct gsm_dlci *dlci;

struct net_device_stats stats;

};

#define STATS(net) (((struct gsm_mux_net *)netdev_priv(net))->stats)

/*

* Each block of data we have queued to go out is in the form of

* a gsm_msg which holds everything we need in a link layer independent

* format

*/

struct gsm_msg {

struct gsm_msg *next;

u8 addr; /* DLCI address + flags */

u8 ctrl; /* Control byte + flags */

unsigned int len; /* Length of data block (can be zero) */

unsigned char *data; /* Points into buffer but not at the start */

unsigned char buffer[0];

};

/*

* Each active data link has a gsm_dlci structure associated which ties

* the link layer to an optional tty (if the tty side is open). To avoid

* complexity right now these are only ever freed up when the mux is

* shut down.

*

* At the moment we don't free DLCI objects until the mux is torn down

* this avoid object life time issues but might be worth review later.

*/

struct gsm_dlci {

struct gsm_mux *gsm;

int addr;

int state;

#define DLCI_CLOSED 0

#define DLCI_OPENING 1 /* Sending SABM not seen UA */

#define DLCI_OPEN 2 /* SABM/UA complete */

#define DLCI_CLOSING 3 /* Sending DISC not seen UA/DM */

struct kref ref; /* freed from port or mux close */

struct mutex mutex;

/* Link layer */

spinlock_t lock; /* Protects the internal state */

struct timer_list t1; /* Retransmit timer for SABM and UA */

int retries;

/* Uplink tty if active */

struct tty_port port; /* The tty bound to this DLCI if there is one */

struct kfifo *fifo; /* Queue fifo for the DLCI */

struct kfifo _fifo; /* For new fifo API porting only */

int adaption; /* Adaption layer in use */

int prev_adaption;

u32 modem_rx; /* Our incoming virtual modem lines */

u32 modem_tx; /* Our outgoing modem lines */

int dead; /* Refuse re-open */

/* Flow control */

int throttled; /* Private copy of throttle state */

int constipated; /* Throttle status for outgoing */

/* Packetised I/O */

struct sk_buff *skb; /* Frame being sent */

struct sk_buff_head skb_list; /* Queued frames */

/* Data handling callback */

void (*data)(struct gsm_dlci *dlci, u8 *data, int len);

void (*prev_data)(struct gsm_dlci *dlci, u8 *data, int len);

struct net_device *net; /* network interface, if created */

};

/* DLCI 0, 62/63 are special or reseved see gsmtty_open */

#define NUM_DLCI 64

/*

* DLCI 0 is used to pass control blocks out of band of the data

* flow (and with a higher link priority). One command can be outstanding

* at a time and we use this structure to manage them. They are created

* and destroyed by the user context, and updated by the receive paths

* and timers

*/

struct gsm_control {

u8 cmd; /* Command we are issuing */

u8 *data; /* Data for the command in case we retransmit */

int len; /* Length of block for retransmission */

int done; /* Done flag */

int error; /* Error if any */

};

/*

* Each GSM mux we have is represented by this structure. If we are

* operating as an ldisc then we use this structure as our ldisc

* state. We need to sort out lifetimes and locking with respect

* to the gsm mux array. For now we don't free DLCI objects that

* have been instantiated until the mux itself is terminated.

*

* To consider further: tty open versus mux shutdown.

*/

struct gsm_mux {

struct tty_struct *tty; /* The tty our ldisc is bound to */

spinlock_t lock;

unsigned int num;

struct kref ref;

/* Events on the GSM channel */

wait_queue_head_t event;

/* Bits for GSM mode decoding */

/* Framing Layer */

unsigned char *buf;

int state;

#define GSM_SEARCH 0

#define GSM_START 1

#define GSM_ADDRESS 2

#define GSM_CONTROL 3

#define GSM_LEN 4

#define GSM_DATA 5

#define GSM_FCS 6

#define GSM_OVERRUN 7

#define GSM_LEN0 8

#define GSM_LEN1 9

#define GSM_SSOF 10

unsigned int len;

unsigned int address;

unsigned int count;

int escape;

int encoding;

u8 control;

u8 fcs;

u8 received_fcs;

u8 *txframe; /* TX framing buffer */

/* Methods for the receiver side */

void (*receive)(struct gsm_mux *gsm, u8 ch);

void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);

/* And transmit side */

int (*output)(struct gsm_mux *mux, u8 *data, int len);

/* Link Layer */

unsigned int mru;

unsigned int mtu;

int initiator; /* Did we initiate connection */

int dead; /* Has the mux been shut down */

struct gsm_dlci *dlci[NUM_DLCI];

int constipated; /* Asked by remote to shut up */

spinlock_t tx_lock;

unsigned int tx_bytes; /* TX data outstanding */

#define TX_THRESH_HI 8192

#define TX_THRESH_LO 2048

struct gsm_msg *tx_head; /* Pending data packets */

struct gsm_msg *tx_tail;

/* Control messages */

struct timer_list t2_timer; /* Retransmit timer for commands */

int cretries; /* Command retry counter */

struct gsm_control *pending_cmd;/* Our current pending command */

spinlock_t control_lock; /* Protects the pending command */

/* Configuration */

int adaption; /* 1 or 2 supported */

u8 ftype; /* UI or UIH */

int t1, t2; /* Timers in 1/100th of a sec */

int n2; /* Retry count */

/* Statistics (not currently exposed) */

unsigned long bad_fcs;

unsigned long malformed;

unsigned long io_error;

unsigned long bad_size;

unsigned long unsupported;

};

/*

* Mux objects - needed so that we can translate a tty index into the

* relevant mux and DLCI.

*/

#define MAX_MUX 4 /* 256 minors */

static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */

static spinlock_t gsm_mux_lock;

static struct tty_driver *gsm_tty_driver;

/*

* This section of the driver logic implements the GSM encodings

* both the basic and the 'advanced'. Reliable transport is not

* supported.

*/

#define CR 0x02

#define EA 0x01

#define PF 0x10

/* I is special: the rest are ..*/

#define RR 0x01

#define UI 0x03

#define RNR 0x05

#define REJ 0x09

#define DM 0x0F

#define SABM 0x2F

#define DISC 0x43

#define UA 0x63

#define UIH 0xEF

/* Channel commands */

#define CMD_NSC 0x09

#define CMD_TEST 0x11

#define CMD_PSC 0x21

#define CMD_RLS 0x29

#define CMD_FCOFF 0x31

#define CMD_PN 0x41

#define CMD_RPN 0x49

#define CMD_FCON 0x51

#define CMD_CLD 0x61

#define CMD_SNC 0x69

#define CMD_MSC 0x71

/* Virtual modem bits */

#define MDM_FC 0x01

#define MDM_RTC 0x02

#define MDM_RTR 0x04

#define MDM_IC 0x20

#define MDM_DV 0x40

#define GSM0_SOF 0xF9

#define GSM1_SOF 0x7E

#define GSM1_ESCAPE 0x7D

#define GSM1_ESCAPE_BITS 0x20

#define XON 0x11

#define XOFF 0x13

static const struct tty_port_operations gsm_port_ops;

/*

* CRC table for GSM 0710

*/

static const u8 gsm_fcs8[256] = {

0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,

0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,

0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,

0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,

0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,

0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,

0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,

0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,

0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,

0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,

0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,

0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,

0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,

0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,

0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,

0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,

0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,

0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,

0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,

0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,

0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,

0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,

0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,

0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,

0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,

0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,

0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,

0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,

0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,

0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,

0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,

0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF

};

#define INIT_FCS 0xFF

#define GOOD_FCS 0xCF

/**

* gsm_fcs_add - update FCS

* @fcs: Current FCS

* @c: Next data

*

* Update the FCS to include c. Uses the algorithm in the specification

* notes.

*/

static inline u8 gsm_fcs_add(u8 fcs, u8 c)

{

return gsm_fcs8[fcs ^ c];

}

/**

* gsm_fcs_add_block - update FCS for a block

* @fcs: Current FCS

* @c: buffer of data

* @len: length of buffer

*

* Update the FCS to include c. Uses the algorithm in the specification

* notes.

*/

static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)

{

while (len--)

fcs = gsm_fcs8[fcs ^ *c++];

return fcs;

}

/**

* gsm_read_ea - read a byte into an EA

* @val: variable holding value

* c: byte going into the EA

*

* Processes one byte of an EA. Updates the passed variable

* and returns 1 if the EA is now completely read

*/

static int gsm_read_ea(unsigned int *val, u8 c)

{

/* Add the next 7 bits into the value */

*val <<= 7;

*val |= c >> 1;

/* Was this the last byte of the EA 1 = yes*/

return c & EA;

}

/**

* gsm_encode_modem - encode modem data bits

* @dlci: DLCI to encode from

*

* Returns the correct GSM encoded modem status bits (6 bit field) for

* the current status of the DLCI and attached tty object

*/

static u8 gsm_encode_modem(const struct gsm_dlci *dlci)

{

u8 modembits = 0;

/* FC is true flow control not modem bits */

if (dlci->throttled)

modembits |= MDM_FC;

if (dlci->modem_tx & TIOCM_DTR)

modembits |= MDM_RTC;

if (dlci->modem_tx & TIOCM_RTS)

modembits |= MDM_RTR;

if (dlci->modem_tx & TIOCM_RI)

modembits |= MDM_IC;

if (dlci->modem_tx & TIOCM_CD)

modembits |= MDM_DV;

return modembits;

}

/**

* gsm_print_packet - display a frame for debug

* @hdr: header to print before decode

* @addr: address EA from the frame

* @cr: C/R bit from the frame

* @control: control including PF bit

* @data: following data bytes

* @dlen: length of data

*

* Displays a packet in human readable format for debugging purposes. The

* style is based on amateur radio LAP-B dump display.

*/

static void gsm_print_packet(const char *hdr, int addr, int cr,

u8 control, const u8 *data, int dlen)

{

if (!(debug & 1))

return;

pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);

switch (control & ~PF) {

case SABM:

pr_cont("SABM");

break;

case UA:

pr_cont("UA");

break;

case DISC:

pr_cont("DISC");

break;

case DM:

pr_cont("DM");

break;

case UI:

pr_cont("UI");

break;

case UIH:

pr_cont("UIH");

break;

default:

if (!(control & 0x01)) {

pr_cont("I N(S)%d N(R)%d",

(control & 0x0E) >> 1, (control & 0xE) >> 5);

} else switch (control & 0x0F) {

case RR:

pr_cont("RR(%d)", (control & 0xE0) >> 5);

break;

case RNR:

pr_cont("RNR(%d)", (control & 0xE0) >> 5);

break;

case REJ:

pr_cont("REJ(%d)", (control & 0xE0) >> 5);

break;

default:

pr_cont("[%02X]", control);

}

}

if (control & PF)

pr_cont("(P)");

else

pr_cont("(F)");

if (dlen) {

int ct = 0;

while (dlen--) {

if (ct % 8 == 0) {

pr_cont("\n");

pr_debug(" ");

}

pr_cont("%02X ", *data++);

ct++;

}

}

pr_cont("\n");

}

/*

* Link level transmission side

*/

/**

* gsm_stuff_packet - bytestuff a packet

* @ibuf: input

* @obuf: output

* @len: length of input

*

* Expand a buffer by bytestuffing it. The worst case size change

* is doubling and the caller is responsible for handing out

* suitable sized buffers.

*/

static int gsm_stuff_frame(const u8 *input, u8 *output, int len)

{

int olen = 0;

while (len--) {

if (*input == GSM1_SOF || *input == GSM1_ESCAPE

|| *input == XON || *input == XOFF) {

*output++ = GSM1_ESCAPE;

*output++ = *input++ ^ GSM1_ESCAPE_BITS;

olen++;

} else

*output++ = *input++;

olen++;

}

return olen;

}

/**

* gsm_send - send a control frame

* @gsm: our GSM mux

* @addr: address for control frame

* @cr: command/response bit

* @control: control byte including PF bit

*

* Format up and transmit a control frame. These do not go via the

* queueing logic as they should be transmitted ahead of data when

* they are needed.

*

* FIXME: Lock versus data TX path

*/

static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)

{

int len;

u8 cbuf[10];

u8 ibuf[3];

switch (gsm->encoding) {

case 0:

cbuf[0] = GSM0_SOF;

cbuf[1] = (addr << 2) | (cr << 1) | EA;

cbuf[2] = control;

cbuf[3] = EA; /* Length of data = 0 */

cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);

cbuf[5] = GSM0_SOF;

len = 6;

break;

case 1:

case 2:

/* Control frame + packing (but not frame stuffing) in mode 1 */

ibuf[0] = (addr << 2) | (cr << 1) | EA;

ibuf[1] = control;

ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);

/* Stuffing may double the size worst case */

len = gsm_stuff_frame(ibuf, cbuf + 1, 3);

/* Now add the SOF markers */

cbuf[0] = GSM1_SOF;

cbuf[len + 1] = GSM1_SOF;

/* FIXME: we can omit the lead one in many cases */

len += 2;

break;

default:

WARN_ON(1);

return;

}

gsm->output(gsm, cbuf, len);

gsm_print_packet("-->", addr, cr, control, NULL, 0);

}

/**

* gsm_response - send a control response

* @gsm: our GSM mux

* @addr: address for control frame

* @control: control byte including PF bit

*

* Format up and transmit a link level response frame.

*/

static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)

{

gsm_send(gsm, addr, 0, control);

}

/**

* gsm_command - send a control command

* @gsm: our GSM mux

* @addr: address for control frame

* @control: control byte including PF bit

*

* Format up and transmit a link level command frame.

*/

static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)

{

gsm_send(gsm, addr, 1, control);

}

/* Data transmission */

#define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */

/**

* gsm_data_alloc - allocate data frame

* @gsm: GSM mux

* @addr: DLCI address

* @len: length excluding header and FCS

* @ctrl: control byte

*

* Allocate a new data buffer for sending frames with data. Space is left

* at the front for header bytes but that is treated as an implementation

* detail and not for the high level code to use

*/

static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,

u8 ctrl)

{

struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,

GFP_ATOMIC);

if (m == NULL)

return NULL;

m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */

m->len = len;

m->addr = addr;

m->ctrl = ctrl;

m->next = NULL;

return m;

}

/**

* gsm_data_kick - poke the queue

* @gsm: GSM Mux

*

* The tty device has called us to indicate that room has appeared in

* the transmit queue. Ram more data into the pipe if we have any

*

* FIXME: lock against link layer control transmissions

*/

static void gsm_data_kick(struct gsm_mux *gsm)

{

struct gsm_msg *msg = gsm->tx_head;

int len;

int skip_sof = 0;

/* FIXME: We need to apply this solely to data messages */

if (gsm->constipated)

return;

while (gsm->tx_head != NULL) {

msg = gsm->tx_head;

if (gsm->encoding != 0) {

gsm->txframe[0] = GSM1_SOF;

len = gsm_stuff_frame(msg->data,

gsm->txframe + 1, msg->len);

gsm->txframe[len + 1] = GSM1_SOF;

len += 2;

} else {

gsm->txframe[0] = GSM0_SOF;

memcpy(gsm->txframe + 1 , msg->data, msg->len);

gsm->txframe[msg->len + 1] = GSM0_SOF;

len = msg->len + 2;

}

if (debug & 4)

print_hex_dump_bytes("gsm_data_kick: ",

DUMP_PREFIX_OFFSET,

gsm->txframe, len);

if (gsm->output(gsm, gsm->txframe + skip_sof,

len - skip_sof) < 0)

break;

/* FIXME: Can eliminate one SOF in many more cases */

gsm->tx_head = msg->next;

if (gsm->tx_head == NULL)

gsm->tx_tail = NULL;

gsm->tx_bytes -= msg->len;

kfree(msg);

/* For a burst of frames skip the extra SOF within the

burst */

skip_sof = 1;

}

}

/**

* __gsm_data_queue - queue a UI or UIH frame

* @dlci: DLCI sending the data

* @msg: message queued

*

* Add data to the transmit queue and try and get stuff moving

* out of the mux tty if not already doing so. The Caller must hold

* the gsm tx lock.

*/

static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)

{

struct gsm_mux *gsm = dlci->gsm;

u8 *dp = msg->data;

u8 *fcs = dp + msg->len;

/* Fill in the header */

if (gsm->encoding == 0) {

if (msg->len < 128)

*--dp = (msg->len << 1) | EA;

else {

*--dp = (msg->len >> 7); /* bits 7 - 15 */

*--dp = (msg->len & 127) << 1; /* bits 0 - 6 */

}

}

*--dp = msg->ctrl;

if (gsm->initiator)

*--dp = (msg->addr << 2) | 2 | EA;

else

*--dp = (msg->addr << 2) | EA;

*fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);

/* Ugly protocol layering violation */

if (msg->ctrl == UI || msg->ctrl == (UI|PF))

*fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);

*fcs = 0xFF - *fcs;

gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,

msg->data, msg->len);

/* Move the header back and adjust the length, also allow for the FCS

now tacked on the end */

msg->len += (msg->data - dp) + 1;

msg->data = dp;

/* Add to the actual output queue */

if (gsm->tx_tail)

gsm->tx_tail->next = msg;

else

gsm->tx_head = msg;

gsm->tx_tail = msg;

gsm->tx_bytes += msg->len;

gsm_data_kick(gsm);

}

/**

* gsm_data_queue - queue a UI or UIH frame

* @dlci: DLCI sending the data

* @msg: message queued

*

* Add data to the transmit queue and try and get stuff moving

* out of the mux tty if not already doing so. Take the

* the gsm tx lock and dlci lock.

*/

static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)

{

unsigned long flags;

spin_lock_irqsave(&dlci->gsm->tx_lock, flags);

__gsm_data_queue(dlci, msg);

spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);

}

/**

* gsm_dlci_data_output - try and push data out of a DLCI

* @gsm: mux

* @dlci: the DLCI to pull data from

*

* Pull data from a DLCI and send it into the transmit queue if there

* is data. Keep to the MRU of the mux. This path handles the usual tty

* interface which is a byte stream with optional modem data.

*

* Caller must hold the tx_lock of the mux.

*/

static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)

{

struct gsm_msg *msg;

u8 *dp;

int len, size;

int h = dlci->adaption - 1;

len = kfifo_len(dlci->fifo);

if (len == 0)

return 0;

/* MTU/MRU count only the data bits */

if (len > gsm->mtu)

len = gsm->mtu;

size = len + h;

msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);

/* FIXME: need a timer or something to kick this so it can't

get stuck with no work outstanding and no buffer free */

if (msg == NULL)

return -ENOMEM;

dp = msg->data;

switch (dlci->adaption) {

case 1: /* Unstructured */

break;

case 2: /* Unstructed with modem bits. Always one byte as we never

send inline break data */

*dp += gsm_encode_modem(dlci);

len--;

break;

}

WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);

__gsm_data_queue(dlci, msg);

/* Bytes of data we used up */

return size;

}

/**

* gsm_dlci_data_output_framed - try and push data out of a DLCI

* @gsm: mux

* @dlci: the DLCI to pull data from

*

* Pull data from a DLCI and send it into the transmit queue if there

* is data. Keep to the MRU of the mux. This path handles framed data

* queued as skbuffs to the DLCI.

*

* Caller must hold the tx_lock of the mux.

*/

static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,

struct gsm_dlci *dlci)

{

struct gsm_msg *msg;

u8 *dp;

int len, size;

int last = 0, first = 0;

int overhead = 0;

/* One byte per frame is used for B/F flags */

if (dlci->adaption == 4)

overhead = 1;

/* dlci->skb is locked by tx_lock */

if (dlci->skb == NULL) {

dlci->skb = skb_dequeue(&dlci->skb_list);

if (dlci->skb == NULL)

return 0;

first = 1;

}

len = dlci->skb->len + overhead;

/* MTU/MRU count only the data bits */

if (len > gsm->mtu) {

if (dlci->adaption == 3) {

/* Over long frame, bin it */

kfree_skb(dlci->skb);

dlci->skb = NULL;

return 0;

}

len = gsm->mtu;

} else

last = 1;

size = len + overhead;

msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);

/* FIXME: need a timer or something to kick this so it can't

get stuck with no work outstanding and no buffer free */

if (msg == NULL)

return -ENOMEM;

dp = msg->data;

if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */

/* Flag byte to carry the start/end info */

*dp++ = last << 7 | first << 6 | 1; /* EA */

len--;

}

memcpy(dp, dlci->skb->data, len);

skb_pull(dlci->skb, len);

__gsm_data_queue(dlci, msg);

if (last) {

kfree_skb(dlci->skb);

dlci->skb = NULL;

}

return size;

}

/**

* gsm_dlci_data_sweep - look for data to send

* @gsm: the GSM mux

*

* Sweep the GSM mux channels in priority order looking for ones with

* data to send. We could do with optimising this scan a bit. We aim

* to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit

* TX_THRESH_LO we get called again

*

* FIXME: We should round robin between groups and in theory you can

* renegotiate DLCI priorities with optional stuff. Needs optimising.

*/

static void gsm_dlci_data_sweep(struct gsm_mux *gsm)

{

int len;

/* Priority ordering: We should do priority with RR of the groups */

int i = 1;

while (i < NUM_DLCI) {

struct gsm_dlci *dlci;

if (gsm->tx_bytes > TX_THRESH_HI)

break;

dlci = gsm->dlci[i];

if (dlci == NULL || dlci->constipated) {

i++;

continue;

}

if (dlci->adaption < 3 && !dlci->net)

len = gsm_dlci_data_output(gsm, dlci);

else

len = gsm_dlci_data_output_framed(gsm, dlci);

if (len < 0)

break;

/* DLCI empty - try the next */

if (len == 0)

i++;

}

}

/**

* gsm_dlci_data_kick - transmit if possible

* @dlci: DLCI to kick

*

* Transmit data from this DLCI if the queue is empty. We can't rely on

* a tty wakeup except when we filled the pipe so we need to fire off

* new data ourselves in other cases.

*/

static void gsm_dlci_data_kick(struct gsm_dlci *dlci)

{

unsigned long flags;

spin_lock_irqsave(&dlci->gsm->tx_lock, flags);

/* If we have nothing running then we need to fire up */

if (dlci->gsm->tx_bytes == 0) {

if (dlci->net)

gsm_dlci_data_output_framed(dlci->gsm, dlci);

else

gsm_dlci_data_output(dlci->gsm, dlci);

} else if (dlci->gsm->tx_bytes < TX_THRESH_LO)

gsm_dlci_data_sweep(dlci->gsm);

spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);

}

/*

* Control message processing

*/

/**

* gsm_control_reply - send a response frame to a control

* @gsm: gsm channel

* @cmd: the command to use

* @data: data to follow encoded info

* @dlen: length of data

*

* Encode up and queue a UI/UIH frame containing our response.

*/

static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,

int dlen)

{