blob: 77623b936538bca5d6af049dc649f3ee9e74a863 [file] [log] [blame]
Alan Coxe1eaea42010-03-26 11:32:54 +00001/*
2 * n_gsm.c GSM 0710 tty multiplexor
3 * Copyright (c) 2009/10 Intel Corporation
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17 *
18 * * THIS IS A DEVELOPMENT SNAPSHOT IT IS NOT A FINAL RELEASE *
19 *
20 * TO DO:
21 * Mostly done: ioctls for setting modes/timing
Alan Cox5f9a31d2010-11-04 15:17:27 +000022 * Partly done: hooks so you can pull off frames to non tty devs
Alan Coxe1eaea42010-03-26 11:32:54 +000023 * Restart DLCI 0 when it closes ?
24 * Test basic encoding
25 * Improve the tx engine
26 * Resolve tx side locking by adding a queue_head and routing
27 * all control traffic via it
28 * General tidy/document
29 * Review the locking/move to refcounts more (mux now moved to an
30 * alloc/free model ready)
31 * Use newest tty open/close port helpers and install hooks
32 * What to do about power functions ?
33 * Termios setting and negotiation
34 * Do we need a 'which mux are you' ioctl to correlate mux and tty sets
35 *
36 */
37
38#include <linux/types.h>
39#include <linux/major.h>
40#include <linux/errno.h>
41#include <linux/signal.h>
42#include <linux/fcntl.h>
43#include <linux/sched.h>
44#include <linux/interrupt.h>
45#include <linux/tty.h>
Alan Coxe1eaea42010-03-26 11:32:54 +000046#include <linux/ctype.h>
47#include <linux/mm.h>
48#include <linux/string.h>
49#include <linux/slab.h>
50#include <linux/poll.h>
51#include <linux/bitops.h>
52#include <linux/file.h>
53#include <linux/uaccess.h>
54#include <linux/module.h>
55#include <linux/timer.h>
56#include <linux/tty_flip.h>
57#include <linux/tty_driver.h>
58#include <linux/serial.h>
59#include <linux/kfifo.h>
60#include <linux/skbuff.h>
61#include <linux/gsmmux.h>
62
63static int debug;
64module_param(debug, int, 0600);
65
66#define T1 (HZ/10)
67#define T2 (HZ/3)
68#define N2 3
69
70/* Use long timers for testing at low speed with debug on */
71#ifdef DEBUG_TIMING
72#define T1 HZ
73#define T2 (2 * HZ)
74#endif
75
Alan Cox5f9a31d2010-11-04 15:17:27 +000076/*
Lucas De Marchi25985ed2011-03-30 22:57:33 -030077 * Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte
Alan Cox5f9a31d2010-11-04 15:17:27 +000078 * limits so this is plenty
79 */
Alan Coxe1eaea42010-03-26 11:32:54 +000080#define MAX_MRU 512
81#define MAX_MTU 512
82
83/*
84 * Each block of data we have queued to go out is in the form of
Lucas De Marchi25985ed2011-03-30 22:57:33 -030085 * a gsm_msg which holds everything we need in a link layer independent
Alan Coxe1eaea42010-03-26 11:32:54 +000086 * format
87 */
88
89struct gsm_msg {
90 struct gsm_msg *next;
91 u8 addr; /* DLCI address + flags */
92 u8 ctrl; /* Control byte + flags */
93 unsigned int len; /* Length of data block (can be zero) */
94 unsigned char *data; /* Points into buffer but not at the start */
95 unsigned char buffer[0];
96};
97
98/*
99 * Each active data link has a gsm_dlci structure associated which ties
100 * the link layer to an optional tty (if the tty side is open). To avoid
101 * complexity right now these are only ever freed up when the mux is
102 * shut down.
103 *
104 * At the moment we don't free DLCI objects until the mux is torn down
105 * this avoid object life time issues but might be worth review later.
106 */
107
108struct gsm_dlci {
109 struct gsm_mux *gsm;
110 int addr;
111 int state;
112#define DLCI_CLOSED 0
113#define DLCI_OPENING 1 /* Sending SABM not seen UA */
114#define DLCI_OPEN 2 /* SABM/UA complete */
115#define DLCI_CLOSING 3 /* Sending DISC not seen UA/DM */
116
117 /* Link layer */
118 spinlock_t lock; /* Protects the internal state */
119 struct timer_list t1; /* Retransmit timer for SABM and UA */
120 int retries;
121 /* Uplink tty if active */
122 struct tty_port port; /* The tty bound to this DLCI if there is one */
123 struct kfifo *fifo; /* Queue fifo for the DLCI */
124 struct kfifo _fifo; /* For new fifo API porting only */
125 int adaption; /* Adaption layer in use */
126 u32 modem_rx; /* Our incoming virtual modem lines */
127 u32 modem_tx; /* Our outgoing modem lines */
128 int dead; /* Refuse re-open */
129 /* Flow control */
130 int throttled; /* Private copy of throttle state */
131 int constipated; /* Throttle status for outgoing */
132 /* Packetised I/O */
133 struct sk_buff *skb; /* Frame being sent */
134 struct sk_buff_head skb_list; /* Queued frames */
135 /* Data handling callback */
136 void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
137};
138
139/* DLCI 0, 62/63 are special or reseved see gsmtty_open */
140
141#define NUM_DLCI 64
142
143/*
144 * DLCI 0 is used to pass control blocks out of band of the data
145 * flow (and with a higher link priority). One command can be outstanding
146 * at a time and we use this structure to manage them. They are created
147 * and destroyed by the user context, and updated by the receive paths
148 * and timers
149 */
150
151struct gsm_control {
152 u8 cmd; /* Command we are issuing */
153 u8 *data; /* Data for the command in case we retransmit */
154 int len; /* Length of block for retransmission */
155 int done; /* Done flag */
156 int error; /* Error if any */
157};
158
159/*
160 * Each GSM mux we have is represented by this structure. If we are
161 * operating as an ldisc then we use this structure as our ldisc
162 * state. We need to sort out lifetimes and locking with respect
163 * to the gsm mux array. For now we don't free DLCI objects that
164 * have been instantiated until the mux itself is terminated.
165 *
166 * To consider further: tty open versus mux shutdown.
167 */
168
169struct gsm_mux {
170 struct tty_struct *tty; /* The tty our ldisc is bound to */
171 spinlock_t lock;
172
173 /* Events on the GSM channel */
174 wait_queue_head_t event;
175
176 /* Bits for GSM mode decoding */
177
178 /* Framing Layer */
179 unsigned char *buf;
180 int state;
181#define GSM_SEARCH 0
182#define GSM_START 1
183#define GSM_ADDRESS 2
184#define GSM_CONTROL 3
185#define GSM_LEN 4
186#define GSM_DATA 5
187#define GSM_FCS 6
188#define GSM_OVERRUN 7
Alan Coxc2f2f002010-11-04 15:17:03 +0000189#define GSM_LEN0 8
190#define GSM_LEN1 9
191#define GSM_SSOF 10
Alan Coxe1eaea42010-03-26 11:32:54 +0000192 unsigned int len;
193 unsigned int address;
194 unsigned int count;
195 int escape;
196 int encoding;
197 u8 control;
198 u8 fcs;
Alan Coxc2f2f002010-11-04 15:17:03 +0000199 u8 received_fcs;
Alan Coxe1eaea42010-03-26 11:32:54 +0000200 u8 *txframe; /* TX framing buffer */
201
202 /* Methods for the receiver side */
203 void (*receive)(struct gsm_mux *gsm, u8 ch);
204 void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
205 /* And transmit side */
206 int (*output)(struct gsm_mux *mux, u8 *data, int len);
207
208 /* Link Layer */
209 unsigned int mru;
210 unsigned int mtu;
211 int initiator; /* Did we initiate connection */
212 int dead; /* Has the mux been shut down */
213 struct gsm_dlci *dlci[NUM_DLCI];
214 int constipated; /* Asked by remote to shut up */
215
216 spinlock_t tx_lock;
217 unsigned int tx_bytes; /* TX data outstanding */
218#define TX_THRESH_HI 8192
219#define TX_THRESH_LO 2048
220 struct gsm_msg *tx_head; /* Pending data packets */
221 struct gsm_msg *tx_tail;
222
223 /* Control messages */
224 struct timer_list t2_timer; /* Retransmit timer for commands */
225 int cretries; /* Command retry counter */
226 struct gsm_control *pending_cmd;/* Our current pending command */
227 spinlock_t control_lock; /* Protects the pending command */
228
229 /* Configuration */
230 int adaption; /* 1 or 2 supported */
231 u8 ftype; /* UI or UIH */
232 int t1, t2; /* Timers in 1/100th of a sec */
233 int n2; /* Retry count */
234
235 /* Statistics (not currently exposed) */
236 unsigned long bad_fcs;
237 unsigned long malformed;
238 unsigned long io_error;
239 unsigned long bad_size;
240 unsigned long unsupported;
241};
242
243
244/*
245 * Mux objects - needed so that we can translate a tty index into the
246 * relevant mux and DLCI.
247 */
248
249#define MAX_MUX 4 /* 256 minors */
250static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */
251static spinlock_t gsm_mux_lock;
252
253/*
254 * This section of the driver logic implements the GSM encodings
255 * both the basic and the 'advanced'. Reliable transport is not
256 * supported.
257 */
258
259#define CR 0x02
260#define EA 0x01
261#define PF 0x10
262
263/* I is special: the rest are ..*/
264#define RR 0x01
265#define UI 0x03
266#define RNR 0x05
267#define REJ 0x09
268#define DM 0x0F
269#define SABM 0x2F
270#define DISC 0x43
271#define UA 0x63
272#define UIH 0xEF
273
274/* Channel commands */
275#define CMD_NSC 0x09
276#define CMD_TEST 0x11
277#define CMD_PSC 0x21
278#define CMD_RLS 0x29
279#define CMD_FCOFF 0x31
280#define CMD_PN 0x41
281#define CMD_RPN 0x49
282#define CMD_FCON 0x51
283#define CMD_CLD 0x61
284#define CMD_SNC 0x69
285#define CMD_MSC 0x71
286
287/* Virtual modem bits */
288#define MDM_FC 0x01
289#define MDM_RTC 0x02
290#define MDM_RTR 0x04
291#define MDM_IC 0x20
292#define MDM_DV 0x40
293
294#define GSM0_SOF 0xF9
Alan Cox5f9a31d2010-11-04 15:17:27 +0000295#define GSM1_SOF 0x7E
Alan Coxe1eaea42010-03-26 11:32:54 +0000296#define GSM1_ESCAPE 0x7D
297#define GSM1_ESCAPE_BITS 0x20
298#define XON 0x11
299#define XOFF 0x13
300
301static const struct tty_port_operations gsm_port_ops;
302
303/*
304 * CRC table for GSM 0710
305 */
306
307static const u8 gsm_fcs8[256] = {
308 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
309 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
310 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
311 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
312 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
313 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
314 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
315 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
316 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
317 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
318 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
319 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
320 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
321 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
322 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
323 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
324 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
325 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
326 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
327 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
328 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
329 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
330 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
331 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
332 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
333 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
334 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
335 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
336 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
337 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
338 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
339 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
340};
341
342#define INIT_FCS 0xFF
343#define GOOD_FCS 0xCF
344
345/**
346 * gsm_fcs_add - update FCS
347 * @fcs: Current FCS
348 * @c: Next data
349 *
350 * Update the FCS to include c. Uses the algorithm in the specification
351 * notes.
352 */
353
354static inline u8 gsm_fcs_add(u8 fcs, u8 c)
355{
356 return gsm_fcs8[fcs ^ c];
357}
358
359/**
360 * gsm_fcs_add_block - update FCS for a block
361 * @fcs: Current FCS
362 * @c: buffer of data
363 * @len: length of buffer
364 *
365 * Update the FCS to include c. Uses the algorithm in the specification
366 * notes.
367 */
368
369static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
370{
371 while (len--)
372 fcs = gsm_fcs8[fcs ^ *c++];
373 return fcs;
374}
375
376/**
377 * gsm_read_ea - read a byte into an EA
378 * @val: variable holding value
379 * c: byte going into the EA
380 *
381 * Processes one byte of an EA. Updates the passed variable
382 * and returns 1 if the EA is now completely read
383 */
384
385static int gsm_read_ea(unsigned int *val, u8 c)
386{
387 /* Add the next 7 bits into the value */
388 *val <<= 7;
389 *val |= c >> 1;
390 /* Was this the last byte of the EA 1 = yes*/
391 return c & EA;
392}
393
394/**
395 * gsm_encode_modem - encode modem data bits
396 * @dlci: DLCI to encode from
397 *
398 * Returns the correct GSM encoded modem status bits (6 bit field) for
399 * the current status of the DLCI and attached tty object
400 */
401
402static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
403{
404 u8 modembits = 0;
405 /* FC is true flow control not modem bits */
406 if (dlci->throttled)
407 modembits |= MDM_FC;
408 if (dlci->modem_tx & TIOCM_DTR)
409 modembits |= MDM_RTC;
410 if (dlci->modem_tx & TIOCM_RTS)
411 modembits |= MDM_RTR;
412 if (dlci->modem_tx & TIOCM_RI)
413 modembits |= MDM_IC;
414 if (dlci->modem_tx & TIOCM_CD)
415 modembits |= MDM_DV;
416 return modembits;
417}
418
419/**
420 * gsm_print_packet - display a frame for debug
421 * @hdr: header to print before decode
422 * @addr: address EA from the frame
423 * @cr: C/R bit from the frame
424 * @control: control including PF bit
425 * @data: following data bytes
426 * @dlen: length of data
427 *
428 * Displays a packet in human readable format for debugging purposes. The
429 * style is based on amateur radio LAP-B dump display.
430 */
431
432static void gsm_print_packet(const char *hdr, int addr, int cr,
433 u8 control, const u8 *data, int dlen)
434{
435 if (!(debug & 1))
436 return;
437
Alan Cox5f9a31d2010-11-04 15:17:27 +0000438 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
Alan Coxe1eaea42010-03-26 11:32:54 +0000439
440 switch (control & ~PF) {
441 case SABM:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000442 pr_cont("SABM");
Alan Coxe1eaea42010-03-26 11:32:54 +0000443 break;
444 case UA:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000445 pr_cont("UA");
Alan Coxe1eaea42010-03-26 11:32:54 +0000446 break;
447 case DISC:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000448 pr_cont("DISC");
Alan Coxe1eaea42010-03-26 11:32:54 +0000449 break;
450 case DM:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000451 pr_cont("DM");
Alan Coxe1eaea42010-03-26 11:32:54 +0000452 break;
453 case UI:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000454 pr_cont("UI");
Alan Coxe1eaea42010-03-26 11:32:54 +0000455 break;
456 case UIH:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000457 pr_cont("UIH");
Alan Coxe1eaea42010-03-26 11:32:54 +0000458 break;
459 default:
460 if (!(control & 0x01)) {
Alan Cox5f9a31d2010-11-04 15:17:27 +0000461 pr_cont("I N(S)%d N(R)%d",
462 (control & 0x0E) >> 1, (control & 0xE) >> 5);
Alan Coxe1eaea42010-03-26 11:32:54 +0000463 } else switch (control & 0x0F) {
Alan Cox5f9a31d2010-11-04 15:17:27 +0000464 case RR:
465 pr_cont("RR(%d)", (control & 0xE0) >> 5);
466 break;
467 case RNR:
468 pr_cont("RNR(%d)", (control & 0xE0) >> 5);
469 break;
470 case REJ:
471 pr_cont("REJ(%d)", (control & 0xE0) >> 5);
472 break;
473 default:
474 pr_cont("[%02X]", control);
Alan Coxe1eaea42010-03-26 11:32:54 +0000475 }
476 }
477
478 if (control & PF)
Alan Cox5f9a31d2010-11-04 15:17:27 +0000479 pr_cont("(P)");
Alan Coxe1eaea42010-03-26 11:32:54 +0000480 else
Alan Cox5f9a31d2010-11-04 15:17:27 +0000481 pr_cont("(F)");
Alan Coxe1eaea42010-03-26 11:32:54 +0000482
483 if (dlen) {
484 int ct = 0;
485 while (dlen--) {
Alan Cox5f9a31d2010-11-04 15:17:27 +0000486 if (ct % 8 == 0) {
487 pr_cont("\n");
488 pr_debug(" ");
489 }
490 pr_cont("%02X ", *data++);
Alan Coxe1eaea42010-03-26 11:32:54 +0000491 ct++;
492 }
493 }
Alan Cox5f9a31d2010-11-04 15:17:27 +0000494 pr_cont("\n");
Alan Coxe1eaea42010-03-26 11:32:54 +0000495}
496
497
498/*
499 * Link level transmission side
500 */
501
502/**
503 * gsm_stuff_packet - bytestuff a packet
504 * @ibuf: input
505 * @obuf: output
506 * @len: length of input
507 *
508 * Expand a buffer by bytestuffing it. The worst case size change
509 * is doubling and the caller is responsible for handing out
510 * suitable sized buffers.
511 */
512
513static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
514{
515 int olen = 0;
516 while (len--) {
517 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
518 || *input == XON || *input == XOFF) {
519 *output++ = GSM1_ESCAPE;
520 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
521 olen++;
522 } else
523 *output++ = *input++;
524 olen++;
525 }
526 return olen;
527}
528
529static void hex_packet(const unsigned char *p, int len)
530{
531 int i;
532 for (i = 0; i < len; i++) {
Alan Cox5f9a31d2010-11-04 15:17:27 +0000533 if (i && (i % 16) == 0) {
534 pr_cont("\n");
535 pr_debug("");
536 }
537 pr_cont("%02X ", *p++);
Alan Coxe1eaea42010-03-26 11:32:54 +0000538 }
Alan Cox5f9a31d2010-11-04 15:17:27 +0000539 pr_cont("\n");
Alan Coxe1eaea42010-03-26 11:32:54 +0000540}
541
542/**
543 * gsm_send - send a control frame
544 * @gsm: our GSM mux
545 * @addr: address for control frame
546 * @cr: command/response bit
547 * @control: control byte including PF bit
548 *
549 * Format up and transmit a control frame. These do not go via the
550 * queueing logic as they should be transmitted ahead of data when
551 * they are needed.
552 *
553 * FIXME: Lock versus data TX path
554 */
555
556static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
557{
558 int len;
559 u8 cbuf[10];
560 u8 ibuf[3];
561
562 switch (gsm->encoding) {
563 case 0:
564 cbuf[0] = GSM0_SOF;
565 cbuf[1] = (addr << 2) | (cr << 1) | EA;
566 cbuf[2] = control;
567 cbuf[3] = EA; /* Length of data = 0 */
568 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
569 cbuf[5] = GSM0_SOF;
570 len = 6;
571 break;
572 case 1:
573 case 2:
574 /* Control frame + packing (but not frame stuffing) in mode 1 */
575 ibuf[0] = (addr << 2) | (cr << 1) | EA;
576 ibuf[1] = control;
577 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
578 /* Stuffing may double the size worst case */
579 len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
580 /* Now add the SOF markers */
581 cbuf[0] = GSM1_SOF;
582 cbuf[len + 1] = GSM1_SOF;
583 /* FIXME: we can omit the lead one in many cases */
584 len += 2;
585 break;
586 default:
587 WARN_ON(1);
588 return;
589 }
590 gsm->output(gsm, cbuf, len);
591 gsm_print_packet("-->", addr, cr, control, NULL, 0);
592}
593
594/**
595 * gsm_response - send a control response
596 * @gsm: our GSM mux
597 * @addr: address for control frame
598 * @control: control byte including PF bit
599 *
600 * Format up and transmit a link level response frame.
601 */
602
603static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
604{
605 gsm_send(gsm, addr, 0, control);
606}
607
608/**
609 * gsm_command - send a control command
610 * @gsm: our GSM mux
611 * @addr: address for control frame
612 * @control: control byte including PF bit
613 *
614 * Format up and transmit a link level command frame.
615 */
616
617static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
618{
619 gsm_send(gsm, addr, 1, control);
620}
621
622/* Data transmission */
623
624#define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
625
626/**
627 * gsm_data_alloc - allocate data frame
628 * @gsm: GSM mux
629 * @addr: DLCI address
630 * @len: length excluding header and FCS
631 * @ctrl: control byte
632 *
633 * Allocate a new data buffer for sending frames with data. Space is left
634 * at the front for header bytes but that is treated as an implementation
635 * detail and not for the high level code to use
636 */
637
638static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
639 u8 ctrl)
640{
641 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
642 GFP_ATOMIC);
643 if (m == NULL)
644 return NULL;
645 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */
646 m->len = len;
647 m->addr = addr;
648 m->ctrl = ctrl;
649 m->next = NULL;
650 return m;
651}
652
653/**
654 * gsm_data_kick - poke the queue
655 * @gsm: GSM Mux
656 *
657 * The tty device has called us to indicate that room has appeared in
658 * the transmit queue. Ram more data into the pipe if we have any
659 *
660 * FIXME: lock against link layer control transmissions
661 */
662
663static void gsm_data_kick(struct gsm_mux *gsm)
664{
665 struct gsm_msg *msg = gsm->tx_head;
666 int len;
667 int skip_sof = 0;
668
669 /* FIXME: We need to apply this solely to data messages */
670 if (gsm->constipated)
671 return;
672
673 while (gsm->tx_head != NULL) {
674 msg = gsm->tx_head;
675 if (gsm->encoding != 0) {
676 gsm->txframe[0] = GSM1_SOF;
677 len = gsm_stuff_frame(msg->data,
678 gsm->txframe + 1, msg->len);
679 gsm->txframe[len + 1] = GSM1_SOF;
680 len += 2;
681 } else {
682 gsm->txframe[0] = GSM0_SOF;
683 memcpy(gsm->txframe + 1 , msg->data, msg->len);
684 gsm->txframe[msg->len + 1] = GSM0_SOF;
685 len = msg->len + 2;
686 }
687
688 if (debug & 4) {
Alan Cox5f9a31d2010-11-04 15:17:27 +0000689 pr_debug("gsm_data_kick:\n");
Alan Coxe1eaea42010-03-26 11:32:54 +0000690 hex_packet(gsm->txframe, len);
691 }
692
693 if (gsm->output(gsm, gsm->txframe + skip_sof,
694 len - skip_sof) < 0)
695 break;
696 /* FIXME: Can eliminate one SOF in many more cases */
697 gsm->tx_head = msg->next;
698 if (gsm->tx_head == NULL)
699 gsm->tx_tail = NULL;
700 gsm->tx_bytes -= msg->len;
701 kfree(msg);
702 /* For a burst of frames skip the extra SOF within the
703 burst */
704 skip_sof = 1;
705 }
706}
707
708/**
709 * __gsm_data_queue - queue a UI or UIH frame
710 * @dlci: DLCI sending the data
711 * @msg: message queued
712 *
713 * Add data to the transmit queue and try and get stuff moving
714 * out of the mux tty if not already doing so. The Caller must hold
715 * the gsm tx lock.
716 */
717
718static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
719{
720 struct gsm_mux *gsm = dlci->gsm;
721 u8 *dp = msg->data;
722 u8 *fcs = dp + msg->len;
723
724 /* Fill in the header */
725 if (gsm->encoding == 0) {
726 if (msg->len < 128)
727 *--dp = (msg->len << 1) | EA;
728 else {
Ken Millsbe7a7412010-12-13 15:27:27 +0000729 *--dp = (msg->len >> 7); /* bits 7 - 15 */
730 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */
Alan Coxe1eaea42010-03-26 11:32:54 +0000731 }
732 }
733
734 *--dp = msg->ctrl;
735 if (gsm->initiator)
736 *--dp = (msg->addr << 2) | 2 | EA;
737 else
738 *--dp = (msg->addr << 2) | EA;
739 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
740 /* Ugly protocol layering violation */
741 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
742 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
743 *fcs = 0xFF - *fcs;
744
745 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
746 msg->data, msg->len);
747
748 /* Move the header back and adjust the length, also allow for the FCS
749 now tacked on the end */
750 msg->len += (msg->data - dp) + 1;
751 msg->data = dp;
752
753 /* Add to the actual output queue */
754 if (gsm->tx_tail)
755 gsm->tx_tail->next = msg;
756 else
757 gsm->tx_head = msg;
758 gsm->tx_tail = msg;
759 gsm->tx_bytes += msg->len;
760 gsm_data_kick(gsm);
761}
762
763/**
764 * gsm_data_queue - queue a UI or UIH frame
765 * @dlci: DLCI sending the data
766 * @msg: message queued
767 *
768 * Add data to the transmit queue and try and get stuff moving
769 * out of the mux tty if not already doing so. Take the
770 * the gsm tx lock and dlci lock.
771 */
772
773static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
774{
775 unsigned long flags;
776 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
777 __gsm_data_queue(dlci, msg);
778 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
779}
780
781/**
782 * gsm_dlci_data_output - try and push data out of a DLCI
783 * @gsm: mux
784 * @dlci: the DLCI to pull data from
785 *
786 * Pull data from a DLCI and send it into the transmit queue if there
787 * is data. Keep to the MRU of the mux. This path handles the usual tty
788 * interface which is a byte stream with optional modem data.
789 *
790 * Caller must hold the tx_lock of the mux.
791 */
792
793static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
794{
795 struct gsm_msg *msg;
796 u8 *dp;
797 int len, size;
798 int h = dlci->adaption - 1;
799
800 len = kfifo_len(dlci->fifo);
801 if (len == 0)
802 return 0;
803
804 /* MTU/MRU count only the data bits */
805 if (len > gsm->mtu)
806 len = gsm->mtu;
807
808 size = len + h;
809
810 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
811 /* FIXME: need a timer or something to kick this so it can't
812 get stuck with no work outstanding and no buffer free */
813 if (msg == NULL)
814 return -ENOMEM;
815 dp = msg->data;
816 switch (dlci->adaption) {
817 case 1: /* Unstructured */
818 break;
819 case 2: /* Unstructed with modem bits. Always one byte as we never
820 send inline break data */
821 *dp += gsm_encode_modem(dlci);
822 len--;
823 break;
824 }
825 WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
826 __gsm_data_queue(dlci, msg);
827 /* Bytes of data we used up */
828 return size;
829}
830
831/**
832 * gsm_dlci_data_output_framed - try and push data out of a DLCI
833 * @gsm: mux
834 * @dlci: the DLCI to pull data from
835 *
836 * Pull data from a DLCI and send it into the transmit queue if there
837 * is data. Keep to the MRU of the mux. This path handles framed data
838 * queued as skbuffs to the DLCI.
839 *
840 * Caller must hold the tx_lock of the mux.
841 */
842
843static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
844 struct gsm_dlci *dlci)
845{
846 struct gsm_msg *msg;
847 u8 *dp;
848 int len, size;
849 int last = 0, first = 0;
850 int overhead = 0;
851
852 /* One byte per frame is used for B/F flags */
853 if (dlci->adaption == 4)
854 overhead = 1;
855
856 /* dlci->skb is locked by tx_lock */
857 if (dlci->skb == NULL) {
858 dlci->skb = skb_dequeue(&dlci->skb_list);
859 if (dlci->skb == NULL)
860 return 0;
861 first = 1;
862 }
863 len = dlci->skb->len + overhead;
864
865 /* MTU/MRU count only the data bits */
866 if (len > gsm->mtu) {
867 if (dlci->adaption == 3) {
868 /* Over long frame, bin it */
869 kfree_skb(dlci->skb);
870 dlci->skb = NULL;
871 return 0;
872 }
873 len = gsm->mtu;
874 } else
875 last = 1;
876
877 size = len + overhead;
878 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
879
880 /* FIXME: need a timer or something to kick this so it can't
881 get stuck with no work outstanding and no buffer free */
882 if (msg == NULL)
883 return -ENOMEM;
884 dp = msg->data;
885
886 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
887 /* Flag byte to carry the start/end info */
888 *dp++ = last << 7 | first << 6 | 1; /* EA */
889 len--;
890 }
891 memcpy(dp, skb_pull(dlci->skb, len), len);
892 __gsm_data_queue(dlci, msg);
893 if (last)
894 dlci->skb = NULL;
895 return size;
896}
897
898/**
899 * gsm_dlci_data_sweep - look for data to send
900 * @gsm: the GSM mux
901 *
902 * Sweep the GSM mux channels in priority order looking for ones with
903 * data to send. We could do with optimising this scan a bit. We aim
904 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
905 * TX_THRESH_LO we get called again
906 *
907 * FIXME: We should round robin between groups and in theory you can
908 * renegotiate DLCI priorities with optional stuff. Needs optimising.
909 */
910
911static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
912{
913 int len;
914 /* Priority ordering: We should do priority with RR of the groups */
915 int i = 1;
Alan Coxe1eaea42010-03-26 11:32:54 +0000916
Alan Coxe1eaea42010-03-26 11:32:54 +0000917 while (i < NUM_DLCI) {
918 struct gsm_dlci *dlci;
919
920 if (gsm->tx_bytes > TX_THRESH_HI)
921 break;
922 dlci = gsm->dlci[i];
923 if (dlci == NULL || dlci->constipated) {
924 i++;
925 continue;
926 }
927 if (dlci->adaption < 3)
928 len = gsm_dlci_data_output(gsm, dlci);
929 else
930 len = gsm_dlci_data_output_framed(gsm, dlci);
931 if (len < 0)
Julia Lawalle73790a2010-08-10 18:03:12 -0700932 break;
Alan Coxe1eaea42010-03-26 11:32:54 +0000933 /* DLCI empty - try the next */
934 if (len == 0)
935 i++;
936 }
Alan Coxe1eaea42010-03-26 11:32:54 +0000937}
938
939/**
940 * gsm_dlci_data_kick - transmit if possible
941 * @dlci: DLCI to kick
942 *
943 * Transmit data from this DLCI if the queue is empty. We can't rely on
944 * a tty wakeup except when we filled the pipe so we need to fire off
945 * new data ourselves in other cases.
946 */
947
948static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
949{
950 unsigned long flags;
951
952 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
953 /* If we have nothing running then we need to fire up */
954 if (dlci->gsm->tx_bytes == 0)
955 gsm_dlci_data_output(dlci->gsm, dlci);
956 else if (dlci->gsm->tx_bytes < TX_THRESH_LO)
957 gsm_dlci_data_sweep(dlci->gsm);
958 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
959}
960
961/*
962 * Control message processing
963 */
964
965
966/**
967 * gsm_control_reply - send a response frame to a control
968 * @gsm: gsm channel
969 * @cmd: the command to use
970 * @data: data to follow encoded info
971 * @dlen: length of data
972 *
973 * Encode up and queue a UI/UIH frame containing our response.
974 */
975
976static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
977 int dlen)
978{
979 struct gsm_msg *msg;
980 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
Ken Mills093d8042010-12-13 15:28:03 +0000981 if (msg == NULL)
982 return;
Alan Coxe1eaea42010-03-26 11:32:54 +0000983 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */
984 msg->data[1] = (dlen << 1) | EA;
985 memcpy(msg->data + 2, data, dlen);
986 gsm_data_queue(gsm->dlci[0], msg);
987}
988
989/**
990 * gsm_process_modem - process received modem status
991 * @tty: virtual tty bound to the DLCI
992 * @dlci: DLCI to affect
993 * @modem: modem bits (full EA)
994 *
995 * Used when a modem control message or line state inline in adaption
996 * layer 2 is processed. Sort out the local modem state and throttles
997 */
998
999static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
1000 u32 modem)
1001{
1002 int mlines = 0;
1003 u8 brk = modem >> 6;
1004
1005 /* Flow control/ready to communicate */
1006 if (modem & MDM_FC) {
1007 /* Need to throttle our output on this device */
1008 dlci->constipated = 1;
1009 }
1010 if (modem & MDM_RTC) {
1011 mlines |= TIOCM_DSR | TIOCM_DTR;
1012 dlci->constipated = 0;
1013 gsm_dlci_data_kick(dlci);
1014 }
1015 /* Map modem bits */
1016 if (modem & MDM_RTR)
1017 mlines |= TIOCM_RTS | TIOCM_CTS;
1018 if (modem & MDM_IC)
1019 mlines |= TIOCM_RI;
1020 if (modem & MDM_DV)
1021 mlines |= TIOCM_CD;
1022
1023 /* Carrier drop -> hangup */
1024 if (tty) {
1025 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1026 if (!(tty->termios->c_cflag & CLOCAL))
1027 tty_hangup(tty);
1028 if (brk & 0x01)
1029 tty_insert_flip_char(tty, 0, TTY_BREAK);
1030 }
1031 dlci->modem_rx = mlines;
1032}
1033
1034/**
1035 * gsm_control_modem - modem status received
1036 * @gsm: GSM channel
1037 * @data: data following command
1038 * @clen: command length
1039 *
1040 * We have received a modem status control message. This is used by
1041 * the GSM mux protocol to pass virtual modem line status and optionally
1042 * to indicate break signals. Unpack it, convert to Linux representation
1043 * and if need be stuff a break message down the tty.
1044 */
1045
1046static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1047{
1048 unsigned int addr = 0;
1049 unsigned int modem = 0;
1050 struct gsm_dlci *dlci;
1051 int len = clen;
1052 u8 *dp = data;
1053 struct tty_struct *tty;
1054
1055 while (gsm_read_ea(&addr, *dp++) == 0) {
1056 len--;
1057 if (len == 0)
1058 return;
1059 }
1060 /* Must be at least one byte following the EA */
1061 len--;
1062 if (len <= 0)
1063 return;
1064
1065 addr >>= 1;
1066 /* Closed port, or invalid ? */
1067 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1068 return;
1069 dlci = gsm->dlci[addr];
1070
1071 while (gsm_read_ea(&modem, *dp++) == 0) {
1072 len--;
1073 if (len == 0)
1074 return;
1075 }
1076 tty = tty_port_tty_get(&dlci->port);
1077 gsm_process_modem(tty, dlci, modem);
1078 if (tty) {
1079 tty_wakeup(tty);
1080 tty_kref_put(tty);
1081 }
1082 gsm_control_reply(gsm, CMD_MSC, data, clen);
1083}
1084
1085/**
1086 * gsm_control_rls - remote line status
1087 * @gsm: GSM channel
1088 * @data: data bytes
1089 * @clen: data length
1090 *
1091 * The modem sends us a two byte message on the control channel whenever
1092 * it wishes to send us an error state from the virtual link. Stuff
1093 * this into the uplink tty if present
1094 */
1095
1096static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1097{
1098 struct tty_struct *tty;
1099 unsigned int addr = 0 ;
1100 u8 bits;
1101 int len = clen;
1102 u8 *dp = data;
1103
1104 while (gsm_read_ea(&addr, *dp++) == 0) {
1105 len--;
1106 if (len == 0)
1107 return;
1108 }
1109 /* Must be at least one byte following ea */
1110 len--;
1111 if (len <= 0)
1112 return;
1113 addr >>= 1;
1114 /* Closed port, or invalid ? */
1115 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1116 return;
1117 /* No error ? */
1118 bits = *dp;
1119 if ((bits & 1) == 0)
1120 return;
1121 /* See if we have an uplink tty */
1122 tty = tty_port_tty_get(&gsm->dlci[addr]->port);
1123
1124 if (tty) {
1125 if (bits & 2)
1126 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1127 if (bits & 4)
1128 tty_insert_flip_char(tty, 0, TTY_PARITY);
1129 if (bits & 8)
1130 tty_insert_flip_char(tty, 0, TTY_FRAME);
1131 tty_flip_buffer_push(tty);
1132 tty_kref_put(tty);
1133 }
1134 gsm_control_reply(gsm, CMD_RLS, data, clen);
1135}
1136
1137static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1138
1139/**
1140 * gsm_control_message - DLCI 0 control processing
1141 * @gsm: our GSM mux
1142 * @command: the command EA
1143 * @data: data beyond the command/length EAs
1144 * @clen: length
1145 *
1146 * Input processor for control messages from the other end of the link.
1147 * Processes the incoming request and queues a response frame or an
1148 * NSC response if not supported
1149 */
1150
1151static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1152 u8 *data, int clen)
1153{
1154 u8 buf[1];
1155 switch (command) {
1156 case CMD_CLD: {
1157 struct gsm_dlci *dlci = gsm->dlci[0];
1158 /* Modem wishes to close down */
1159 if (dlci) {
1160 dlci->dead = 1;
1161 gsm->dead = 1;
1162 gsm_dlci_begin_close(dlci);
1163 }
1164 }
1165 break;
1166 case CMD_TEST:
1167 /* Modem wishes to test, reply with the data */
1168 gsm_control_reply(gsm, CMD_TEST, data, clen);
1169 break;
1170 case CMD_FCON:
1171 /* Modem wants us to STFU */
1172 gsm->constipated = 1;
1173 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1174 break;
1175 case CMD_FCOFF:
1176 /* Modem can accept data again */
1177 gsm->constipated = 0;
1178 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1179 /* Kick the link in case it is idling */
1180 gsm_data_kick(gsm);
1181 break;
1182 case CMD_MSC:
1183 /* Out of band modem line change indicator for a DLCI */
1184 gsm_control_modem(gsm, data, clen);
1185 break;
1186 case CMD_RLS:
1187 /* Out of band error reception for a DLCI */
1188 gsm_control_rls(gsm, data, clen);
1189 break;
1190 case CMD_PSC:
1191 /* Modem wishes to enter power saving state */
1192 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1193 break;
1194 /* Optional unsupported commands */
1195 case CMD_PN: /* Parameter negotiation */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001196 case CMD_RPN: /* Remote port negotiation */
1197 case CMD_SNC: /* Service negotiation command */
Alan Coxe1eaea42010-03-26 11:32:54 +00001198 default:
1199 /* Reply to bad commands with an NSC */
1200 buf[0] = command;
1201 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1202 break;
1203 }
1204}
1205
1206/**
1207 * gsm_control_response - process a response to our control
1208 * @gsm: our GSM mux
1209 * @command: the command (response) EA
1210 * @data: data beyond the command/length EA
1211 * @clen: length
1212 *
1213 * Process a response to an outstanding command. We only allow a single
1214 * control message in flight so this is fairly easy. All the clean up
1215 * is done by the caller, we just update the fields, flag it as done
1216 * and return
1217 */
1218
1219static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1220 u8 *data, int clen)
1221{
1222 struct gsm_control *ctrl;
1223 unsigned long flags;
1224
1225 spin_lock_irqsave(&gsm->control_lock, flags);
1226
1227 ctrl = gsm->pending_cmd;
1228 /* Does the reply match our command */
1229 command |= 1;
1230 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1231 /* Our command was replied to, kill the retry timer */
1232 del_timer(&gsm->t2_timer);
1233 gsm->pending_cmd = NULL;
1234 /* Rejected by the other end */
1235 if (command == CMD_NSC)
1236 ctrl->error = -EOPNOTSUPP;
1237 ctrl->done = 1;
1238 wake_up(&gsm->event);
1239 }
1240 spin_unlock_irqrestore(&gsm->control_lock, flags);
1241}
1242
1243/**
Alan Cox5f9a31d2010-11-04 15:17:27 +00001244 * gsm_control_transmit - send control packet
Alan Coxe1eaea42010-03-26 11:32:54 +00001245 * @gsm: gsm mux
1246 * @ctrl: frame to send
1247 *
1248 * Send out a pending control command (called under control lock)
1249 */
1250
1251static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1252{
Eric Bénarded43b472011-03-09 19:24:49 +01001253 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype);
Alan Coxe1eaea42010-03-26 11:32:54 +00001254 if (msg == NULL)
1255 return;
1256 msg->data[0] = (ctrl->cmd << 1) | 2 | EA; /* command */
1257 memcpy(msg->data + 1, ctrl->data, ctrl->len);
1258 gsm_data_queue(gsm->dlci[0], msg);
1259}
1260
1261/**
1262 * gsm_control_retransmit - retransmit a control frame
1263 * @data: pointer to our gsm object
1264 *
1265 * Called off the T2 timer expiry in order to retransmit control frames
1266 * that have been lost in the system somewhere. The control_lock protects
1267 * us from colliding with another sender or a receive completion event.
1268 * In that situation the timer may still occur in a small window but
1269 * gsm->pending_cmd will be NULL and we just let the timer expire.
1270 */
1271
1272static void gsm_control_retransmit(unsigned long data)
1273{
1274 struct gsm_mux *gsm = (struct gsm_mux *)data;
1275 struct gsm_control *ctrl;
1276 unsigned long flags;
1277 spin_lock_irqsave(&gsm->control_lock, flags);
1278 ctrl = gsm->pending_cmd;
1279 if (ctrl) {
1280 gsm->cretries--;
1281 if (gsm->cretries == 0) {
1282 gsm->pending_cmd = NULL;
1283 ctrl->error = -ETIMEDOUT;
1284 ctrl->done = 1;
1285 spin_unlock_irqrestore(&gsm->control_lock, flags);
1286 wake_up(&gsm->event);
1287 return;
1288 }
1289 gsm_control_transmit(gsm, ctrl);
1290 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1291 }
1292 spin_unlock_irqrestore(&gsm->control_lock, flags);
1293}
1294
1295/**
1296 * gsm_control_send - send a control frame on DLCI 0
1297 * @gsm: the GSM channel
1298 * @command: command to send including CR bit
1299 * @data: bytes of data (must be kmalloced)
1300 * @len: length of the block to send
1301 *
1302 * Queue and dispatch a control command. Only one command can be
1303 * active at a time. In theory more can be outstanding but the matching
1304 * gets really complicated so for now stick to one outstanding.
1305 */
1306
1307static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1308 unsigned int command, u8 *data, int clen)
1309{
1310 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1311 GFP_KERNEL);
1312 unsigned long flags;
1313 if (ctrl == NULL)
1314 return NULL;
1315retry:
1316 wait_event(gsm->event, gsm->pending_cmd == NULL);
1317 spin_lock_irqsave(&gsm->control_lock, flags);
1318 if (gsm->pending_cmd != NULL) {
1319 spin_unlock_irqrestore(&gsm->control_lock, flags);
1320 goto retry;
1321 }
1322 ctrl->cmd = command;
1323 ctrl->data = data;
1324 ctrl->len = clen;
1325 gsm->pending_cmd = ctrl;
1326 gsm->cretries = gsm->n2;
1327 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1328 gsm_control_transmit(gsm, ctrl);
1329 spin_unlock_irqrestore(&gsm->control_lock, flags);
1330 return ctrl;
1331}
1332
1333/**
1334 * gsm_control_wait - wait for a control to finish
1335 * @gsm: GSM mux
1336 * @control: control we are waiting on
1337 *
1338 * Waits for the control to complete or time out. Frees any used
1339 * resources and returns 0 for success, or an error if the remote
1340 * rejected or ignored the request.
1341 */
1342
1343static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1344{
1345 int err;
1346 wait_event(gsm->event, control->done == 1);
1347 err = control->error;
1348 kfree(control);
1349 return err;
1350}
1351
1352
1353/*
1354 * DLCI level handling: Needs krefs
1355 */
1356
1357/*
1358 * State transitions and timers
1359 */
1360
1361/**
1362 * gsm_dlci_close - a DLCI has closed
1363 * @dlci: DLCI that closed
1364 *
1365 * Perform processing when moving a DLCI into closed state. If there
1366 * is an attached tty this is hung up
1367 */
1368
1369static void gsm_dlci_close(struct gsm_dlci *dlci)
1370{
1371 del_timer(&dlci->t1);
1372 if (debug & 8)
Alan Cox5f9a31d2010-11-04 15:17:27 +00001373 pr_debug("DLCI %d goes closed.\n", dlci->addr);
Alan Coxe1eaea42010-03-26 11:32:54 +00001374 dlci->state = DLCI_CLOSED;
1375 if (dlci->addr != 0) {
1376 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1377 if (tty) {
1378 tty_hangup(tty);
1379 tty_kref_put(tty);
1380 }
1381 kfifo_reset(dlci->fifo);
1382 } else
1383 dlci->gsm->dead = 1;
1384 wake_up(&dlci->gsm->event);
1385 /* A DLCI 0 close is a MUX termination so we need to kick that
1386 back to userspace somehow */
1387}
1388
1389/**
1390 * gsm_dlci_open - a DLCI has opened
1391 * @dlci: DLCI that opened
1392 *
1393 * Perform processing when moving a DLCI into open state.
1394 */
1395
1396static void gsm_dlci_open(struct gsm_dlci *dlci)
1397{
1398 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1399 open -> open */
1400 del_timer(&dlci->t1);
1401 /* This will let a tty open continue */
1402 dlci->state = DLCI_OPEN;
1403 if (debug & 8)
Alan Cox5f9a31d2010-11-04 15:17:27 +00001404 pr_debug("DLCI %d goes open.\n", dlci->addr);
Alan Coxe1eaea42010-03-26 11:32:54 +00001405 wake_up(&dlci->gsm->event);
1406}
1407
1408/**
1409 * gsm_dlci_t1 - T1 timer expiry
1410 * @dlci: DLCI that opened
1411 *
1412 * The T1 timer handles retransmits of control frames (essentially of
1413 * SABM and DISC). We resend the command until the retry count runs out
1414 * in which case an opening port goes back to closed and a closing port
1415 * is simply put into closed state (any further frames from the other
1416 * end will get a DM response)
1417 */
1418
1419static void gsm_dlci_t1(unsigned long data)
1420{
1421 struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1422 struct gsm_mux *gsm = dlci->gsm;
1423
1424 switch (dlci->state) {
1425 case DLCI_OPENING:
1426 dlci->retries--;
1427 if (dlci->retries) {
1428 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1429 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1430 } else
1431 gsm_dlci_close(dlci);
1432 break;
1433 case DLCI_CLOSING:
1434 dlci->retries--;
1435 if (dlci->retries) {
1436 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1437 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1438 } else
1439 gsm_dlci_close(dlci);
1440 break;
1441 }
1442}
1443
1444/**
1445 * gsm_dlci_begin_open - start channel open procedure
1446 * @dlci: DLCI to open
1447 *
1448 * Commence opening a DLCI from the Linux side. We issue SABM messages
1449 * to the modem which should then reply with a UA, at which point we
1450 * will move into open state. Opening is done asynchronously with retry
1451 * running off timers and the responses.
1452 */
1453
1454static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1455{
1456 struct gsm_mux *gsm = dlci->gsm;
1457 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1458 return;
1459 dlci->retries = gsm->n2;
1460 dlci->state = DLCI_OPENING;
1461 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1462 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1463}
1464
1465/**
1466 * gsm_dlci_begin_close - start channel open procedure
1467 * @dlci: DLCI to open
1468 *
1469 * Commence closing a DLCI from the Linux side. We issue DISC messages
1470 * to the modem which should then reply with a UA, at which point we
1471 * will move into closed state. Closing is done asynchronously with retry
1472 * off timers. We may also receive a DM reply from the other end which
1473 * indicates the channel was already closed.
1474 */
1475
1476static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1477{
1478 struct gsm_mux *gsm = dlci->gsm;
1479 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1480 return;
1481 dlci->retries = gsm->n2;
1482 dlci->state = DLCI_CLOSING;
1483 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1484 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1485}
1486
1487/**
1488 * gsm_dlci_data - data arrived
1489 * @dlci: channel
1490 * @data: block of bytes received
1491 * @len: length of received block
1492 *
1493 * A UI or UIH frame has arrived which contains data for a channel
1494 * other than the control channel. If the relevant virtual tty is
1495 * open we shovel the bits down it, if not we drop them.
1496 */
1497
1498static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int len)
1499{
1500 /* krefs .. */
1501 struct tty_port *port = &dlci->port;
1502 struct tty_struct *tty = tty_port_tty_get(port);
1503 unsigned int modem = 0;
1504
1505 if (debug & 16)
Alan Cox5f9a31d2010-11-04 15:17:27 +00001506 pr_debug("%d bytes for tty %p\n", len, tty);
Alan Coxe1eaea42010-03-26 11:32:54 +00001507 if (tty) {
1508 switch (dlci->adaption) {
Alan Cox5f9a31d2010-11-04 15:17:27 +00001509 /* Unsupported types */
1510 /* Packetised interruptible data */
1511 case 4:
1512 break;
1513 /* Packetised uininterruptible voice/data */
1514 case 3:
1515 break;
1516 /* Asynchronous serial with line state in each frame */
1517 case 2:
1518 while (gsm_read_ea(&modem, *data++) == 0) {
1519 len--;
1520 if (len == 0)
1521 return;
1522 }
1523 gsm_process_modem(tty, dlci, modem);
1524 /* Line state will go via DLCI 0 controls only */
1525 case 1:
1526 default:
1527 tty_insert_flip_string(tty, data, len);
1528 tty_flip_buffer_push(tty);
Alan Coxe1eaea42010-03-26 11:32:54 +00001529 }
1530 tty_kref_put(tty);
1531 }
1532}
1533
1534/**
1535 * gsm_dlci_control - data arrived on control channel
1536 * @dlci: channel
1537 * @data: block of bytes received
1538 * @len: length of received block
1539 *
1540 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1541 * control channel. This should contain a command EA followed by
1542 * control data bytes. The command EA contains a command/response bit
1543 * and we divide up the work accordingly.
1544 */
1545
1546static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1547{
1548 /* See what command is involved */
1549 unsigned int command = 0;
1550 while (len-- > 0) {
1551 if (gsm_read_ea(&command, *data++) == 1) {
1552 int clen = *data++;
1553 len--;
1554 /* FIXME: this is properly an EA */
1555 clen >>= 1;
1556 /* Malformed command ? */
1557 if (clen > len)
1558 return;
1559 if (command & 1)
1560 gsm_control_message(dlci->gsm, command,
1561 data, clen);
1562 else
1563 gsm_control_response(dlci->gsm, command,
1564 data, clen);
1565 return;
1566 }
1567 }
1568}
1569
1570/*
1571 * Allocate/Free DLCI channels
1572 */
1573
1574/**
1575 * gsm_dlci_alloc - allocate a DLCI
1576 * @gsm: GSM mux
1577 * @addr: address of the DLCI
1578 *
1579 * Allocate and install a new DLCI object into the GSM mux.
1580 *
1581 * FIXME: review locking races
1582 */
1583
1584static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1585{
1586 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1587 if (dlci == NULL)
1588 return NULL;
1589 spin_lock_init(&dlci->lock);
1590 dlci->fifo = &dlci->_fifo;
1591 if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1592 kfree(dlci);
1593 return NULL;
1594 }
1595
1596 skb_queue_head_init(&dlci->skb_list);
1597 init_timer(&dlci->t1);
1598 dlci->t1.function = gsm_dlci_t1;
1599 dlci->t1.data = (unsigned long)dlci;
1600 tty_port_init(&dlci->port);
1601 dlci->port.ops = &gsm_port_ops;
1602 dlci->gsm = gsm;
1603 dlci->addr = addr;
1604 dlci->adaption = gsm->adaption;
1605 dlci->state = DLCI_CLOSED;
1606 if (addr)
1607 dlci->data = gsm_dlci_data;
1608 else
1609 dlci->data = gsm_dlci_command;
1610 gsm->dlci[addr] = dlci;
1611 return dlci;
1612}
1613
1614/**
1615 * gsm_dlci_free - release DLCI
1616 * @dlci: DLCI to destroy
1617 *
1618 * Free up a DLCI. Currently to keep the lifetime rules sane we only
1619 * clean up DLCI objects when the MUX closes rather than as the port
1620 * is closed down on both the tty and mux levels.
1621 *
1622 * Can sleep.
1623 */
1624static void gsm_dlci_free(struct gsm_dlci *dlci)
1625{
1626 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1627 if (tty) {
1628 tty_vhangup(tty);
1629 tty_kref_put(tty);
1630 }
1631 del_timer_sync(&dlci->t1);
1632 dlci->gsm->dlci[dlci->addr] = NULL;
1633 kfifo_free(dlci->fifo);
1634 kfree(dlci);
1635}
1636
Alan Coxe1eaea42010-03-26 11:32:54 +00001637/*
1638 * LAPBish link layer logic
1639 */
1640
1641/**
1642 * gsm_queue - a GSM frame is ready to process
1643 * @gsm: pointer to our gsm mux
1644 *
1645 * At this point in time a frame has arrived and been demangled from
1646 * the line encoding. All the differences between the encodings have
1647 * been handled below us and the frame is unpacked into the structures.
1648 * The fcs holds the header FCS but any data FCS must be added here.
1649 */
1650
1651static void gsm_queue(struct gsm_mux *gsm)
1652{
1653 struct gsm_dlci *dlci;
1654 u8 cr;
1655 int address;
1656 /* We have to sneak a look at the packet body to do the FCS.
1657 A somewhat layering violation in the spec */
1658
1659 if ((gsm->control & ~PF) == UI)
1660 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
Mikhail Kshevetskiy9db4e432011-03-27 04:05:00 +04001661 if (gsm->encoding == 0){
1662 /* WARNING: gsm->received_fcs is used for gsm->encoding = 0 only.
1663 In this case it contain the last piece of data
1664 required to generate final CRC */
1665 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1666 }
Alan Coxe1eaea42010-03-26 11:32:54 +00001667 if (gsm->fcs != GOOD_FCS) {
1668 gsm->bad_fcs++;
1669 if (debug & 4)
Alan Cox5f9a31d2010-11-04 15:17:27 +00001670 pr_debug("BAD FCS %02x\n", gsm->fcs);
Alan Coxe1eaea42010-03-26 11:32:54 +00001671 return;
1672 }
1673 address = gsm->address >> 1;
1674 if (address >= NUM_DLCI)
1675 goto invalid;
1676
1677 cr = gsm->address & 1; /* C/R bit */
1678
1679 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1680
1681 cr ^= 1 - gsm->initiator; /* Flip so 1 always means command */
1682 dlci = gsm->dlci[address];
1683
1684 switch (gsm->control) {
1685 case SABM|PF:
1686 if (cr == 0)
1687 goto invalid;
1688 if (dlci == NULL)
1689 dlci = gsm_dlci_alloc(gsm, address);
1690 if (dlci == NULL)
1691 return;
1692 if (dlci->dead)
1693 gsm_response(gsm, address, DM);
1694 else {
1695 gsm_response(gsm, address, UA);
1696 gsm_dlci_open(dlci);
1697 }
1698 break;
1699 case DISC|PF:
1700 if (cr == 0)
1701 goto invalid;
1702 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1703 gsm_response(gsm, address, DM);
1704 return;
1705 }
1706 /* Real close complete */
1707 gsm_response(gsm, address, UA);
1708 gsm_dlci_close(dlci);
1709 break;
1710 case UA:
1711 case UA|PF:
1712 if (cr == 0 || dlci == NULL)
1713 break;
1714 switch (dlci->state) {
1715 case DLCI_CLOSING:
1716 gsm_dlci_close(dlci);
1717 break;
1718 case DLCI_OPENING:
1719 gsm_dlci_open(dlci);
1720 break;
1721 }
1722 break;
1723 case DM: /* DM can be valid unsolicited */
1724 case DM|PF:
1725 if (cr)
1726 goto invalid;
1727 if (dlci == NULL)
1728 return;
1729 gsm_dlci_close(dlci);
1730 break;
1731 case UI:
1732 case UI|PF:
1733 case UIH:
1734 case UIH|PF:
1735#if 0
1736 if (cr)
1737 goto invalid;
1738#endif
1739 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1740 gsm_command(gsm, address, DM|PF);
1741 return;
1742 }
1743 dlci->data(dlci, gsm->buf, gsm->len);
1744 break;
1745 default:
1746 goto invalid;
1747 }
1748 return;
1749invalid:
1750 gsm->malformed++;
1751 return;
1752}
1753
1754
1755/**
1756 * gsm0_receive - perform processing for non-transparency
1757 * @gsm: gsm data for this ldisc instance
1758 * @c: character
1759 *
1760 * Receive bytes in gsm mode 0
1761 */
1762
1763static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1764{
Alan Coxc2f2f002010-11-04 15:17:03 +00001765 unsigned int len;
1766
Alan Coxe1eaea42010-03-26 11:32:54 +00001767 switch (gsm->state) {
1768 case GSM_SEARCH: /* SOF marker */
1769 if (c == GSM0_SOF) {
1770 gsm->state = GSM_ADDRESS;
1771 gsm->address = 0;
1772 gsm->len = 0;
1773 gsm->fcs = INIT_FCS;
1774 }
Alan Coxc2f2f002010-11-04 15:17:03 +00001775 break;
1776 case GSM_ADDRESS: /* Address EA */
Alan Coxe1eaea42010-03-26 11:32:54 +00001777 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1778 if (gsm_read_ea(&gsm->address, c))
1779 gsm->state = GSM_CONTROL;
1780 break;
1781 case GSM_CONTROL: /* Control Byte */
1782 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1783 gsm->control = c;
Alan Coxc2f2f002010-11-04 15:17:03 +00001784 gsm->state = GSM_LEN0;
Alan Coxe1eaea42010-03-26 11:32:54 +00001785 break;
Alan Coxc2f2f002010-11-04 15:17:03 +00001786 case GSM_LEN0: /* Length EA */
Alan Coxe1eaea42010-03-26 11:32:54 +00001787 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1788 if (gsm_read_ea(&gsm->len, c)) {
1789 if (gsm->len > gsm->mru) {
1790 gsm->bad_size++;
1791 gsm->state = GSM_SEARCH;
1792 break;
1793 }
1794 gsm->count = 0;
Alan Coxc2f2f002010-11-04 15:17:03 +00001795 if (!gsm->len)
1796 gsm->state = GSM_FCS;
1797 else
1798 gsm->state = GSM_DATA;
1799 break;
Alan Coxe1eaea42010-03-26 11:32:54 +00001800 }
Alan Coxc2f2f002010-11-04 15:17:03 +00001801 gsm->state = GSM_LEN1;
1802 break;
1803 case GSM_LEN1:
1804 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1805 len = c;
1806 gsm->len |= len << 7;
1807 if (gsm->len > gsm->mru) {
1808 gsm->bad_size++;
1809 gsm->state = GSM_SEARCH;
1810 break;
1811 }
1812 gsm->count = 0;
1813 if (!gsm->len)
1814 gsm->state = GSM_FCS;
1815 else
1816 gsm->state = GSM_DATA;
Alan Coxe1eaea42010-03-26 11:32:54 +00001817 break;
1818 case GSM_DATA: /* Data */
1819 gsm->buf[gsm->count++] = c;
1820 if (gsm->count == gsm->len)
1821 gsm->state = GSM_FCS;
1822 break;
1823 case GSM_FCS: /* FCS follows the packet */
Alan Coxc2f2f002010-11-04 15:17:03 +00001824 gsm->received_fcs = c;
1825 if (c == GSM0_SOF) {
1826 gsm->state = GSM_SEARCH;
1827 break;
1828 }
Alan Coxe1eaea42010-03-26 11:32:54 +00001829 gsm_queue(gsm);
Alan Coxc2f2f002010-11-04 15:17:03 +00001830 gsm->state = GSM_SSOF;
1831 break;
1832 case GSM_SSOF:
1833 if (c == GSM0_SOF) {
1834 gsm->state = GSM_SEARCH;
1835 break;
1836 }
Alan Coxe1eaea42010-03-26 11:32:54 +00001837 break;
1838 }
1839}
1840
1841/**
Alan Coxc2f2f002010-11-04 15:17:03 +00001842 * gsm1_receive - perform processing for non-transparency
Alan Coxe1eaea42010-03-26 11:32:54 +00001843 * @gsm: gsm data for this ldisc instance
1844 * @c: character
1845 *
1846 * Receive bytes in mode 1 (Advanced option)
1847 */
1848
1849static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1850{
1851 if (c == GSM1_SOF) {
1852 /* EOF is only valid in frame if we have got to the data state
1853 and received at least one byte (the FCS) */
1854 if (gsm->state == GSM_DATA && gsm->count) {
1855 /* Extract the FCS */
1856 gsm->count--;
1857 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1858 gsm->len = gsm->count;
1859 gsm_queue(gsm);
1860 gsm->state = GSM_START;
1861 return;
1862 }
1863 /* Any partial frame was a runt so go back to start */
1864 if (gsm->state != GSM_START) {
1865 gsm->malformed++;
1866 gsm->state = GSM_START;
1867 }
1868 /* A SOF in GSM_START means we are still reading idling or
1869 framing bytes */
1870 return;
1871 }
1872
1873 if (c == GSM1_ESCAPE) {
1874 gsm->escape = 1;
1875 return;
1876 }
1877
1878 /* Only an unescaped SOF gets us out of GSM search */
1879 if (gsm->state == GSM_SEARCH)
1880 return;
1881
1882 if (gsm->escape) {
1883 c ^= GSM1_ESCAPE_BITS;
1884 gsm->escape = 0;
1885 }
1886 switch (gsm->state) {
1887 case GSM_START: /* First byte after SOF */
1888 gsm->address = 0;
1889 gsm->state = GSM_ADDRESS;
1890 gsm->fcs = INIT_FCS;
1891 /* Drop through */
1892 case GSM_ADDRESS: /* Address continuation */
1893 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1894 if (gsm_read_ea(&gsm->address, c))
1895 gsm->state = GSM_CONTROL;
1896 break;
1897 case GSM_CONTROL: /* Control Byte */
1898 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1899 gsm->control = c;
1900 gsm->count = 0;
1901 gsm->state = GSM_DATA;
1902 break;
1903 case GSM_DATA: /* Data */
Alan Cox5f9a31d2010-11-04 15:17:27 +00001904 if (gsm->count > gsm->mru) { /* Allow one for the FCS */
Alan Coxe1eaea42010-03-26 11:32:54 +00001905 gsm->state = GSM_OVERRUN;
1906 gsm->bad_size++;
1907 } else
1908 gsm->buf[gsm->count++] = c;
1909 break;
1910 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */
1911 break;
1912 }
1913}
1914
1915/**
1916 * gsm_error - handle tty error
1917 * @gsm: ldisc data
1918 * @data: byte received (may be invalid)
1919 * @flag: error received
1920 *
1921 * Handle an error in the receipt of data for a frame. Currently we just
1922 * go back to hunting for a SOF.
1923 *
1924 * FIXME: better diagnostics ?
1925 */
1926
1927static void gsm_error(struct gsm_mux *gsm,
1928 unsigned char data, unsigned char flag)
1929{
1930 gsm->state = GSM_SEARCH;
1931 gsm->io_error++;
1932}
1933
1934/**
1935 * gsm_cleanup_mux - generic GSM protocol cleanup
1936 * @gsm: our mux
1937 *
1938 * Clean up the bits of the mux which are the same for all framing
1939 * protocols. Remove the mux from the mux table, stop all the timers
1940 * and then shut down each device hanging up the channels as we go.
1941 */
1942
1943void gsm_cleanup_mux(struct gsm_mux *gsm)
1944{
1945 int i;
1946 struct gsm_dlci *dlci = gsm->dlci[0];
1947 struct gsm_msg *txq;
1948
1949 gsm->dead = 1;
1950
1951 spin_lock(&gsm_mux_lock);
1952 for (i = 0; i < MAX_MUX; i++) {
1953 if (gsm_mux[i] == gsm) {
1954 gsm_mux[i] = NULL;
1955 break;
1956 }
1957 }
1958 spin_unlock(&gsm_mux_lock);
1959 WARN_ON(i == MAX_MUX);
1960
1961 del_timer_sync(&gsm->t2_timer);
1962 /* Now we are sure T2 has stopped */
1963 if (dlci) {
1964 dlci->dead = 1;
1965 gsm_dlci_begin_close(dlci);
1966 wait_event_interruptible(gsm->event,
1967 dlci->state == DLCI_CLOSED);
1968 }
1969 /* Free up any link layer users */
1970 for (i = 0; i < NUM_DLCI; i++)
1971 if (gsm->dlci[i])
1972 gsm_dlci_free(gsm->dlci[i]);
1973 /* Now wipe the queues */
1974 for (txq = gsm->tx_head; txq != NULL; txq = gsm->tx_head) {
1975 gsm->tx_head = txq->next;
1976 kfree(txq);
1977 }
1978 gsm->tx_tail = NULL;
1979}
1980EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
1981
1982/**
1983 * gsm_activate_mux - generic GSM setup
1984 * @gsm: our mux
1985 *
1986 * Set up the bits of the mux which are the same for all framing
1987 * protocols. Add the mux to the mux table so it can be opened and
1988 * finally kick off connecting to DLCI 0 on the modem.
1989 */
1990
1991int gsm_activate_mux(struct gsm_mux *gsm)
1992{
1993 struct gsm_dlci *dlci;
1994 int i = 0;
1995
1996 init_timer(&gsm->t2_timer);
1997 gsm->t2_timer.function = gsm_control_retransmit;
1998 gsm->t2_timer.data = (unsigned long)gsm;
1999 init_waitqueue_head(&gsm->event);
2000 spin_lock_init(&gsm->control_lock);
2001 spin_lock_init(&gsm->tx_lock);
2002
2003 if (gsm->encoding == 0)
2004 gsm->receive = gsm0_receive;
2005 else
2006 gsm->receive = gsm1_receive;
2007 gsm->error = gsm_error;
2008
2009 spin_lock(&gsm_mux_lock);
2010 for (i = 0; i < MAX_MUX; i++) {
2011 if (gsm_mux[i] == NULL) {
2012 gsm_mux[i] = gsm;
2013 break;
2014 }
2015 }
2016 spin_unlock(&gsm_mux_lock);
2017 if (i == MAX_MUX)
2018 return -EBUSY;
2019
2020 dlci = gsm_dlci_alloc(gsm, 0);
2021 if (dlci == NULL)
2022 return -ENOMEM;
2023 gsm->dead = 0; /* Tty opens are now permissible */
2024 return 0;
2025}
2026EXPORT_SYMBOL_GPL(gsm_activate_mux);
2027
2028/**
2029 * gsm_free_mux - free up a mux
2030 * @mux: mux to free
2031 *
2032 * Dispose of allocated resources for a dead mux. No refcounting
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002033 * at present so the mux must be truly dead.
Alan Coxe1eaea42010-03-26 11:32:54 +00002034 */
2035void gsm_free_mux(struct gsm_mux *gsm)
2036{
2037 kfree(gsm->txframe);
2038 kfree(gsm->buf);
2039 kfree(gsm);
2040}
2041EXPORT_SYMBOL_GPL(gsm_free_mux);
2042
2043/**
2044 * gsm_alloc_mux - allocate a mux
2045 *
2046 * Creates a new mux ready for activation.
2047 */
2048
2049struct gsm_mux *gsm_alloc_mux(void)
2050{
2051 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2052 if (gsm == NULL)
2053 return NULL;
2054 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2055 if (gsm->buf == NULL) {
2056 kfree(gsm);
2057 return NULL;
2058 }
2059 gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2060 if (gsm->txframe == NULL) {
2061 kfree(gsm->buf);
2062 kfree(gsm);
2063 return NULL;
2064 }
2065 spin_lock_init(&gsm->lock);
2066
2067 gsm->t1 = T1;
2068 gsm->t2 = T2;
2069 gsm->n2 = N2;
2070 gsm->ftype = UIH;
2071 gsm->initiator = 0;
2072 gsm->adaption = 1;
2073 gsm->encoding = 1;
2074 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
2075 gsm->mtu = 64;
2076 gsm->dead = 1; /* Avoid early tty opens */
2077
2078 return gsm;
2079}
2080EXPORT_SYMBOL_GPL(gsm_alloc_mux);
2081
Alan Coxe1eaea42010-03-26 11:32:54 +00002082/**
2083 * gsmld_output - write to link
2084 * @gsm: our mux
2085 * @data: bytes to output
2086 * @len: size
2087 *
2088 * Write a block of data from the GSM mux to the data channel. This
2089 * will eventually be serialized from above but at the moment isn't.
2090 */
2091
2092static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2093{
2094 if (tty_write_room(gsm->tty) < len) {
2095 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2096 return -ENOSPC;
2097 }
2098 if (debug & 4) {
Alan Cox5f9a31d2010-11-04 15:17:27 +00002099 pr_debug("-->%d bytes out\n", len);
Alan Coxe1eaea42010-03-26 11:32:54 +00002100 hex_packet(data, len);
2101 }
2102 gsm->tty->ops->write(gsm->tty, data, len);
2103 return len;
2104}
2105
2106/**
2107 * gsmld_attach_gsm - mode set up
2108 * @tty: our tty structure
2109 * @gsm: our mux
2110 *
2111 * Set up the MUX for basic mode and commence connecting to the
2112 * modem. Currently called from the line discipline set up but
2113 * will need moving to an ioctl path.
2114 */
2115
2116static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2117{
2118 int ret;
2119
2120 gsm->tty = tty_kref_get(tty);
2121 gsm->output = gsmld_output;
2122 ret = gsm_activate_mux(gsm);
2123 if (ret != 0)
2124 tty_kref_put(gsm->tty);
2125 return ret;
2126}
2127
2128
2129/**
2130 * gsmld_detach_gsm - stop doing 0710 mux
Justin P. Mattock70f23fd2011-05-10 10:16:21 +02002131 * @tty: tty attached to the mux
Alan Coxe1eaea42010-03-26 11:32:54 +00002132 * @gsm: mux
2133 *
2134 * Shutdown and then clean up the resources used by the line discipline
2135 */
2136
2137static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2138{
2139 WARN_ON(tty != gsm->tty);
2140 gsm_cleanup_mux(gsm);
2141 tty_kref_put(gsm->tty);
2142 gsm->tty = NULL;
2143}
2144
2145static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2146 char *fp, int count)
2147{
2148 struct gsm_mux *gsm = tty->disc_data;
2149 const unsigned char *dp;
2150 char *f;
2151 int i;
2152 char buf[64];
2153 char flags;
2154
2155 if (debug & 4) {
Alan Cox5f9a31d2010-11-04 15:17:27 +00002156 pr_debug("Inbytes %dd\n", count);
Alan Coxe1eaea42010-03-26 11:32:54 +00002157 hex_packet(cp, count);
2158 }
2159
2160 for (i = count, dp = cp, f = fp; i; i--, dp++) {
2161 flags = *f++;
2162 switch (flags) {
2163 case TTY_NORMAL:
2164 gsm->receive(gsm, *dp);
2165 break;
2166 case TTY_OVERRUN:
2167 case TTY_BREAK:
2168 case TTY_PARITY:
2169 case TTY_FRAME:
2170 gsm->error(gsm, *dp, flags);
2171 break;
2172 default:
Alan Cox5f9a31d2010-11-04 15:17:27 +00002173 WARN_ONCE("%s: unknown flag %d\n",
Alan Coxe1eaea42010-03-26 11:32:54 +00002174 tty_name(tty, buf), flags);
2175 break;
2176 }
2177 }
2178 /* FASYNC if needed ? */
2179 /* If clogged call tty_throttle(tty); */
2180}
2181
2182/**
2183 * gsmld_chars_in_buffer - report available bytes
2184 * @tty: tty device
2185 *
2186 * Report the number of characters buffered to be delivered to user
2187 * at this instant in time.
2188 *
2189 * Locking: gsm lock
2190 */
2191
2192static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
2193{
2194 return 0;
2195}
2196
2197/**
2198 * gsmld_flush_buffer - clean input queue
2199 * @tty: terminal device
2200 *
2201 * Flush the input buffer. Called when the line discipline is
2202 * being closed, when the tty layer wants the buffer flushed (eg
2203 * at hangup).
2204 */
2205
2206static void gsmld_flush_buffer(struct tty_struct *tty)
2207{
2208}
2209
2210/**
2211 * gsmld_close - close the ldisc for this tty
2212 * @tty: device
2213 *
2214 * Called from the terminal layer when this line discipline is
2215 * being shut down, either because of a close or becsuse of a
2216 * discipline change. The function will not be called while other
2217 * ldisc methods are in progress.
2218 */
2219
2220static void gsmld_close(struct tty_struct *tty)
2221{
2222 struct gsm_mux *gsm = tty->disc_data;
2223
2224 gsmld_detach_gsm(tty, gsm);
2225
2226 gsmld_flush_buffer(tty);
2227 /* Do other clean up here */
2228 gsm_free_mux(gsm);
2229}
2230
2231/**
2232 * gsmld_open - open an ldisc
2233 * @tty: terminal to open
2234 *
2235 * Called when this line discipline is being attached to the
2236 * terminal device. Can sleep. Called serialized so that no
2237 * other events will occur in parallel. No further open will occur
2238 * until a close.
2239 */
2240
2241static int gsmld_open(struct tty_struct *tty)
2242{
2243 struct gsm_mux *gsm;
2244
2245 if (tty->ops->write == NULL)
2246 return -EINVAL;
2247
2248 /* Attach our ldisc data */
2249 gsm = gsm_alloc_mux();
2250 if (gsm == NULL)
2251 return -ENOMEM;
2252
2253 tty->disc_data = gsm;
2254 tty->receive_room = 65536;
2255
2256 /* Attach the initial passive connection */
2257 gsm->encoding = 1;
2258 return gsmld_attach_gsm(tty, gsm);
2259}
2260
2261/**
2262 * gsmld_write_wakeup - asynchronous I/O notifier
2263 * @tty: tty device
2264 *
2265 * Required for the ptys, serial driver etc. since processes
2266 * that attach themselves to the master and rely on ASYNC
2267 * IO must be woken up
2268 */
2269
2270static void gsmld_write_wakeup(struct tty_struct *tty)
2271{
2272 struct gsm_mux *gsm = tty->disc_data;
Dan Carpenter328be392010-05-25 11:37:17 +02002273 unsigned long flags;
Alan Coxe1eaea42010-03-26 11:32:54 +00002274
2275 /* Queue poll */
2276 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2277 gsm_data_kick(gsm);
Dan Carpenter328be392010-05-25 11:37:17 +02002278 if (gsm->tx_bytes < TX_THRESH_LO) {
2279 spin_lock_irqsave(&gsm->tx_lock, flags);
Alan Coxe1eaea42010-03-26 11:32:54 +00002280 gsm_dlci_data_sweep(gsm);
Dan Carpenter328be392010-05-25 11:37:17 +02002281 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2282 }
Alan Coxe1eaea42010-03-26 11:32:54 +00002283}
2284
2285/**
2286 * gsmld_read - read function for tty
2287 * @tty: tty device
2288 * @file: file object
2289 * @buf: userspace buffer pointer
2290 * @nr: size of I/O
2291 *
2292 * Perform reads for the line discipline. We are guaranteed that the
2293 * line discipline will not be closed under us but we may get multiple
2294 * parallel readers and must handle this ourselves. We may also get
2295 * a hangup. Always called in user context, may sleep.
2296 *
2297 * This code must be sure never to sleep through a hangup.
2298 */
2299
2300static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2301 unsigned char __user *buf, size_t nr)
2302{
2303 return -EOPNOTSUPP;
2304}
2305
2306/**
2307 * gsmld_write - write function for tty
2308 * @tty: tty device
2309 * @file: file object
2310 * @buf: userspace buffer pointer
2311 * @nr: size of I/O
2312 *
2313 * Called when the owner of the device wants to send a frame
2314 * itself (or some other control data). The data is transferred
2315 * as-is and must be properly framed and checksummed as appropriate
2316 * by userspace. Frames are either sent whole or not at all as this
2317 * avoids pain user side.
2318 */
2319
2320static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2321 const unsigned char *buf, size_t nr)
2322{
2323 int space = tty_write_room(tty);
2324 if (space >= nr)
2325 return tty->ops->write(tty, buf, nr);
2326 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2327 return -ENOBUFS;
2328}
2329
2330/**
2331 * gsmld_poll - poll method for N_GSM0710
2332 * @tty: terminal device
2333 * @file: file accessing it
2334 * @wait: poll table
2335 *
2336 * Called when the line discipline is asked to poll() for data or
2337 * for special events. This code is not serialized with respect to
2338 * other events save open/close.
2339 *
2340 * This code must be sure never to sleep through a hangup.
2341 * Called without the kernel lock held - fine
2342 */
2343
2344static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2345 poll_table *wait)
2346{
2347 unsigned int mask = 0;
2348 struct gsm_mux *gsm = tty->disc_data;
2349
2350 poll_wait(file, &tty->read_wait, wait);
2351 poll_wait(file, &tty->write_wait, wait);
2352 if (tty_hung_up_p(file))
2353 mask |= POLLHUP;
2354 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2355 mask |= POLLOUT | POLLWRNORM;
2356 if (gsm->dead)
2357 mask |= POLLHUP;
2358 return mask;
2359}
2360
2361static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2362 struct gsm_config *c)
2363{
2364 int need_close = 0;
2365 int need_restart = 0;
2366
2367 /* Stuff we don't support yet - UI or I frame transport, windowing */
Alan Cox5f9a31d2010-11-04 15:17:27 +00002368 if ((c->adaption != 1 && c->adaption != 2) || c->k)
Alan Coxe1eaea42010-03-26 11:32:54 +00002369 return -EOPNOTSUPP;
2370 /* Check the MRU/MTU range looks sane */
2371 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2372 return -EINVAL;
2373 if (c->n2 < 3)
2374 return -EINVAL;
2375 if (c->encapsulation > 1) /* Basic, advanced, no I */
2376 return -EINVAL;
2377 if (c->initiator > 1)
2378 return -EINVAL;
2379 if (c->i == 0 || c->i > 2) /* UIH and UI only */
2380 return -EINVAL;
2381 /*
2382 * See what is needed for reconfiguration
2383 */
2384
2385 /* Timing fields */
2386 if (c->t1 != 0 && c->t1 != gsm->t1)
2387 need_restart = 1;
2388 if (c->t2 != 0 && c->t2 != gsm->t2)
2389 need_restart = 1;
2390 if (c->encapsulation != gsm->encoding)
2391 need_restart = 1;
2392 if (c->adaption != gsm->adaption)
2393 need_restart = 1;
2394 /* Requires care */
2395 if (c->initiator != gsm->initiator)
2396 need_close = 1;
2397 if (c->mru != gsm->mru)
2398 need_restart = 1;
2399 if (c->mtu != gsm->mtu)
2400 need_restart = 1;
2401
2402 /*
2403 * Close down what is needed, restart and initiate the new
2404 * configuration
2405 */
2406
2407 if (need_close || need_restart) {
2408 gsm_dlci_begin_close(gsm->dlci[0]);
2409 /* This will timeout if the link is down due to N2 expiring */
2410 wait_event_interruptible(gsm->event,
2411 gsm->dlci[0]->state == DLCI_CLOSED);
2412 if (signal_pending(current))
2413 return -EINTR;
2414 }
2415 if (need_restart)
2416 gsm_cleanup_mux(gsm);
2417
2418 gsm->initiator = c->initiator;
2419 gsm->mru = c->mru;
Ken Mills91f78f32011-01-25 14:17:45 +00002420 gsm->mtu = c->mtu;
Alan Coxe1eaea42010-03-26 11:32:54 +00002421 gsm->encoding = c->encapsulation;
2422 gsm->adaption = c->adaption;
Ken Mills820e62e2010-11-04 15:16:24 +00002423 gsm->n2 = c->n2;
Alan Coxe1eaea42010-03-26 11:32:54 +00002424
2425 if (c->i == 1)
2426 gsm->ftype = UIH;
2427 else if (c->i == 2)
2428 gsm->ftype = UI;
2429
2430 if (c->t1)
2431 gsm->t1 = c->t1;
2432 if (c->t2)
2433 gsm->t2 = c->t2;
2434
2435 /* FIXME: We need to separate activation/deactivation from adding
2436 and removing from the mux array */
2437 if (need_restart)
2438 gsm_activate_mux(gsm);
2439 if (gsm->initiator && need_close)
2440 gsm_dlci_begin_open(gsm->dlci[0]);
2441 return 0;
2442}
2443
2444static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2445 unsigned int cmd, unsigned long arg)
2446{
2447 struct gsm_config c;
2448 struct gsm_mux *gsm = tty->disc_data;
2449
2450 switch (cmd) {
2451 case GSMIOC_GETCONF:
2452 memset(&c, 0, sizeof(c));
2453 c.adaption = gsm->adaption;
2454 c.encapsulation = gsm->encoding;
2455 c.initiator = gsm->initiator;
2456 c.t1 = gsm->t1;
2457 c.t2 = gsm->t2;
2458 c.t3 = 0; /* Not supported */
2459 c.n2 = gsm->n2;
2460 if (gsm->ftype == UIH)
2461 c.i = 1;
2462 else
2463 c.i = 2;
Alan Cox5f9a31d2010-11-04 15:17:27 +00002464 pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
Alan Coxe1eaea42010-03-26 11:32:54 +00002465 c.mru = gsm->mru;
2466 c.mtu = gsm->mtu;
2467 c.k = 0;
2468 if (copy_to_user((void *)arg, &c, sizeof(c)))
2469 return -EFAULT;
2470 return 0;
2471 case GSMIOC_SETCONF:
2472 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2473 return -EFAULT;
2474 return gsmld_config(tty, gsm, &c);
2475 default:
2476 return n_tty_ioctl_helper(tty, file, cmd, arg);
2477 }
2478}
2479
2480
2481/* Line discipline for real tty */
2482struct tty_ldisc_ops tty_ldisc_packet = {
2483 .owner = THIS_MODULE,
2484 .magic = TTY_LDISC_MAGIC,
2485 .name = "n_gsm",
2486 .open = gsmld_open,
2487 .close = gsmld_close,
2488 .flush_buffer = gsmld_flush_buffer,
2489 .chars_in_buffer = gsmld_chars_in_buffer,
2490 .read = gsmld_read,
2491 .write = gsmld_write,
2492 .ioctl = gsmld_ioctl,
2493 .poll = gsmld_poll,
2494 .receive_buf = gsmld_receive_buf,
2495 .write_wakeup = gsmld_write_wakeup
2496};
2497
2498/*
2499 * Virtual tty side
2500 */
2501
2502#define TX_SIZE 512
2503
2504static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2505{
2506 u8 modembits[5];
2507 struct gsm_control *ctrl;
2508 int len = 2;
2509
2510 if (brk)
2511 len++;
2512
2513 modembits[0] = len << 1 | EA; /* Data bytes */
2514 modembits[1] = dlci->addr << 2 | 3; /* DLCI, EA, 1 */
2515 modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2516 if (brk)
2517 modembits[3] = brk << 4 | 2 | EA; /* Valid, EA */
2518 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2519 if (ctrl == NULL)
2520 return -ENOMEM;
2521 return gsm_control_wait(dlci->gsm, ctrl);
2522}
2523
2524static int gsm_carrier_raised(struct tty_port *port)
2525{
2526 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2527 /* Not yet open so no carrier info */
2528 if (dlci->state != DLCI_OPEN)
2529 return 0;
2530 if (debug & 2)
2531 return 1;
2532 return dlci->modem_rx & TIOCM_CD;
2533}
2534
2535static void gsm_dtr_rts(struct tty_port *port, int onoff)
2536{
2537 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2538 unsigned int modem_tx = dlci->modem_tx;
2539 if (onoff)
2540 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2541 else
2542 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2543 if (modem_tx != dlci->modem_tx) {
2544 dlci->modem_tx = modem_tx;
2545 gsmtty_modem_update(dlci, 0);
2546 }
2547}
2548
2549static const struct tty_port_operations gsm_port_ops = {
2550 .carrier_raised = gsm_carrier_raised,
2551 .dtr_rts = gsm_dtr_rts,
2552};
2553
2554
2555static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2556{
2557 struct gsm_mux *gsm;
2558 struct gsm_dlci *dlci;
2559 struct tty_port *port;
2560 unsigned int line = tty->index;
2561 unsigned int mux = line >> 6;
2562
2563 line = line & 0x3F;
2564
2565 if (mux >= MAX_MUX)
2566 return -ENXIO;
2567 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2568 if (gsm_mux[mux] == NULL)
2569 return -EUNATCH;
2570 if (line == 0 || line > 61) /* 62/63 reserved */
2571 return -ECHRNG;
2572 gsm = gsm_mux[mux];
2573 if (gsm->dead)
2574 return -EL2HLT;
2575 dlci = gsm->dlci[line];
2576 if (dlci == NULL)
2577 dlci = gsm_dlci_alloc(gsm, line);
2578 if (dlci == NULL)
2579 return -ENOMEM;
2580 port = &dlci->port;
2581 port->count++;
2582 tty->driver_data = dlci;
2583 tty_port_tty_set(port, tty);
2584
2585 dlci->modem_rx = 0;
2586 /* We could in theory open and close before we wait - eg if we get
2587 a DM straight back. This is ok as that will have caused a hangup */
2588 set_bit(ASYNCB_INITIALIZED, &port->flags);
2589 /* Start sending off SABM messages */
2590 gsm_dlci_begin_open(dlci);
2591 /* And wait for virtual carrier */
2592 return tty_port_block_til_ready(port, tty, filp);
2593}
2594
2595static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2596{
2597 struct gsm_dlci *dlci = tty->driver_data;
2598 if (dlci == NULL)
2599 return;
2600 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
2601 return;
2602 gsm_dlci_begin_close(dlci);
2603 tty_port_close_end(&dlci->port, tty);
2604 tty_port_tty_set(&dlci->port, NULL);
2605}
2606
2607static void gsmtty_hangup(struct tty_struct *tty)
2608{
2609 struct gsm_dlci *dlci = tty->driver_data;
2610 tty_port_hangup(&dlci->port);
2611 gsm_dlci_begin_close(dlci);
2612}
2613
2614static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2615 int len)
2616{
2617 struct gsm_dlci *dlci = tty->driver_data;
2618 /* Stuff the bytes into the fifo queue */
2619 int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
2620 /* Need to kick the channel */
2621 gsm_dlci_data_kick(dlci);
2622 return sent;
2623}
2624
2625static int gsmtty_write_room(struct tty_struct *tty)
2626{
2627 struct gsm_dlci *dlci = tty->driver_data;
2628 return TX_SIZE - kfifo_len(dlci->fifo);
2629}
2630
2631static int gsmtty_chars_in_buffer(struct tty_struct *tty)
2632{
2633 struct gsm_dlci *dlci = tty->driver_data;
2634 return kfifo_len(dlci->fifo);
2635}
2636
2637static void gsmtty_flush_buffer(struct tty_struct *tty)
2638{
2639 struct gsm_dlci *dlci = tty->driver_data;
2640 /* Caution needed: If we implement reliable transport classes
2641 then the data being transmitted can't simply be junked once
2642 it has first hit the stack. Until then we can just blow it
2643 away */
2644 kfifo_reset(dlci->fifo);
2645 /* Need to unhook this DLCI from the transmit queue logic */
2646}
2647
2648static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
2649{
2650 /* The FIFO handles the queue so the kernel will do the right
2651 thing waiting on chars_in_buffer before calling us. No work
2652 to do here */
2653}
2654
Alan Cox60b33c12011-02-14 16:26:14 +00002655static int gsmtty_tiocmget(struct tty_struct *tty)
Alan Coxe1eaea42010-03-26 11:32:54 +00002656{
2657 struct gsm_dlci *dlci = tty->driver_data;
2658 return dlci->modem_rx;
2659}
2660
Alan Cox20b9d172011-02-14 16:26:50 +00002661static int gsmtty_tiocmset(struct tty_struct *tty,
Alan Coxe1eaea42010-03-26 11:32:54 +00002662 unsigned int set, unsigned int clear)
2663{
2664 struct gsm_dlci *dlci = tty->driver_data;
2665 unsigned int modem_tx = dlci->modem_tx;
2666
2667 modem_tx &= clear;
2668 modem_tx |= set;
2669
2670 if (modem_tx != dlci->modem_tx) {
2671 dlci->modem_tx = modem_tx;
2672 return gsmtty_modem_update(dlci, 0);
2673 }
2674 return 0;
2675}
2676
2677
Alan Cox6caa76b2011-02-14 16:27:22 +00002678static int gsmtty_ioctl(struct tty_struct *tty,
Alan Coxe1eaea42010-03-26 11:32:54 +00002679 unsigned int cmd, unsigned long arg)
2680{
2681 return -ENOIOCTLCMD;
2682}
2683
2684static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
2685{
2686 /* For the moment its fixed. In actual fact the speed information
2687 for the virtual channel can be propogated in both directions by
2688 the RPN control message. This however rapidly gets nasty as we
2689 then have to remap modem signals each way according to whether
2690 our virtual cable is null modem etc .. */
2691 tty_termios_copy_hw(tty->termios, old);
2692}
2693
2694static void gsmtty_throttle(struct tty_struct *tty)
2695{
2696 struct gsm_dlci *dlci = tty->driver_data;
2697 if (tty->termios->c_cflag & CRTSCTS)
2698 dlci->modem_tx &= ~TIOCM_DTR;
2699 dlci->throttled = 1;
2700 /* Send an MSC with DTR cleared */
2701 gsmtty_modem_update(dlci, 0);
2702}
2703
2704static void gsmtty_unthrottle(struct tty_struct *tty)
2705{
2706 struct gsm_dlci *dlci = tty->driver_data;
2707 if (tty->termios->c_cflag & CRTSCTS)
2708 dlci->modem_tx |= TIOCM_DTR;
2709 dlci->throttled = 0;
2710 /* Send an MSC with DTR set */
2711 gsmtty_modem_update(dlci, 0);
2712}
2713
2714static int gsmtty_break_ctl(struct tty_struct *tty, int state)
2715{
2716 struct gsm_dlci *dlci = tty->driver_data;
2717 int encode = 0; /* Off */
2718
2719 if (state == -1) /* "On indefinitely" - we can't encode this
2720 properly */
2721 encode = 0x0F;
2722 else if (state > 0) {
2723 encode = state / 200; /* mS to encoding */
2724 if (encode > 0x0F)
2725 encode = 0x0F; /* Best effort */
2726 }
2727 return gsmtty_modem_update(dlci, encode);
2728}
2729
2730static struct tty_driver *gsm_tty_driver;
2731
2732/* Virtual ttys for the demux */
2733static const struct tty_operations gsmtty_ops = {
2734 .open = gsmtty_open,
2735 .close = gsmtty_close,
2736 .write = gsmtty_write,
2737 .write_room = gsmtty_write_room,
2738 .chars_in_buffer = gsmtty_chars_in_buffer,
2739 .flush_buffer = gsmtty_flush_buffer,
2740 .ioctl = gsmtty_ioctl,
2741 .throttle = gsmtty_throttle,
2742 .unthrottle = gsmtty_unthrottle,
2743 .set_termios = gsmtty_set_termios,
2744 .hangup = gsmtty_hangup,
2745 .wait_until_sent = gsmtty_wait_until_sent,
2746 .tiocmget = gsmtty_tiocmget,
2747 .tiocmset = gsmtty_tiocmset,
2748 .break_ctl = gsmtty_break_ctl,
2749};
2750
2751
2752
2753static int __init gsm_init(void)
2754{
2755 /* Fill in our line protocol discipline, and register it */
2756 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
2757 if (status != 0) {
Alan Cox5f9a31d2010-11-04 15:17:27 +00002758 pr_err("n_gsm: can't register line discipline (err = %d)\n",
2759 status);
Alan Coxe1eaea42010-03-26 11:32:54 +00002760 return status;
2761 }
2762
2763 gsm_tty_driver = alloc_tty_driver(256);
2764 if (!gsm_tty_driver) {
2765 tty_unregister_ldisc(N_GSM0710);
Alan Cox5f9a31d2010-11-04 15:17:27 +00002766 pr_err("gsm_init: tty allocation failed.\n");
Alan Coxe1eaea42010-03-26 11:32:54 +00002767 return -EINVAL;
2768 }
2769 gsm_tty_driver->owner = THIS_MODULE;
2770 gsm_tty_driver->driver_name = "gsmtty";
2771 gsm_tty_driver->name = "gsmtty";
2772 gsm_tty_driver->major = 0; /* Dynamic */
2773 gsm_tty_driver->minor_start = 0;
2774 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
2775 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
2776 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
Alan Cox5f9a31d2010-11-04 15:17:27 +00002777 | TTY_DRIVER_HARDWARE_BREAK;
Alan Coxe1eaea42010-03-26 11:32:54 +00002778 gsm_tty_driver->init_termios = tty_std_termios;
2779 /* Fixme */
2780 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
2781 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
2782
2783 spin_lock_init(&gsm_mux_lock);
2784
2785 if (tty_register_driver(gsm_tty_driver)) {
2786 put_tty_driver(gsm_tty_driver);
2787 tty_unregister_ldisc(N_GSM0710);
Alan Cox5f9a31d2010-11-04 15:17:27 +00002788 pr_err("gsm_init: tty registration failed.\n");
Alan Coxe1eaea42010-03-26 11:32:54 +00002789 return -EBUSY;
2790 }
Alan Cox5f9a31d2010-11-04 15:17:27 +00002791 pr_debug("gsm_init: loaded as %d,%d.\n",
2792 gsm_tty_driver->major, gsm_tty_driver->minor_start);
Alan Coxe1eaea42010-03-26 11:32:54 +00002793 return 0;
2794}
2795
2796static void __exit gsm_exit(void)
2797{
2798 int status = tty_unregister_ldisc(N_GSM0710);
2799 if (status != 0)
Alan Cox5f9a31d2010-11-04 15:17:27 +00002800 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
2801 status);
Alan Coxe1eaea42010-03-26 11:32:54 +00002802 tty_unregister_driver(gsm_tty_driver);
2803 put_tty_driver(gsm_tty_driver);
Alan Coxe1eaea42010-03-26 11:32:54 +00002804}
2805
2806module_init(gsm_init);
2807module_exit(gsm_exit);
2808
2809
2810MODULE_LICENSE("GPL");
2811MODULE_ALIAS_LDISC(N_GSM0710);