blob: 4cb0d0a3e57b774c22d6a8909cc20a7615c6ed60 [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 ?
Alan Coxe1eaea42010-03-26 11:32:54 +000024 * Improve the tx engine
25 * Resolve tx side locking by adding a queue_head and routing
26 * all control traffic via it
27 * General tidy/document
28 * Review the locking/move to refcounts more (mux now moved to an
29 * alloc/free model ready)
30 * Use newest tty open/close port helpers and install hooks
31 * What to do about power functions ?
32 * Termios setting and negotiation
33 * Do we need a 'which mux are you' ioctl to correlate mux and tty sets
34 *
35 */
36
37#include <linux/types.h>
38#include <linux/major.h>
39#include <linux/errno.h>
40#include <linux/signal.h>
41#include <linux/fcntl.h>
42#include <linux/sched.h>
43#include <linux/interrupt.h>
44#include <linux/tty.h>
Alan Coxe1eaea42010-03-26 11:32:54 +000045#include <linux/ctype.h>
46#include <linux/mm.h>
47#include <linux/string.h>
48#include <linux/slab.h>
49#include <linux/poll.h>
50#include <linux/bitops.h>
51#include <linux/file.h>
52#include <linux/uaccess.h>
53#include <linux/module.h>
54#include <linux/timer.h>
55#include <linux/tty_flip.h>
56#include <linux/tty_driver.h>
57#include <linux/serial.h>
58#include <linux/kfifo.h>
59#include <linux/skbuff.h>
Russ Gorbybcd5abe2011-06-16 14:20:12 -070060#include <net/arp.h>
61#include <linux/ip.h>
62#include <linux/netdevice.h>
63#include <linux/etherdevice.h>
Alan Coxe1eaea42010-03-26 11:32:54 +000064#include <linux/gsmmux.h>
65
66static int debug;
67module_param(debug, int, 0600);
68
69#define T1 (HZ/10)
70#define T2 (HZ/3)
71#define N2 3
72
73/* Use long timers for testing at low speed with debug on */
74#ifdef DEBUG_TIMING
75#define T1 HZ
76#define T2 (2 * HZ)
77#endif
78
Alan Cox5f9a31d2010-11-04 15:17:27 +000079/*
Lucas De Marchi25985ed2011-03-30 22:57:33 -030080 * Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte
Alan Cox5f9a31d2010-11-04 15:17:27 +000081 * limits so this is plenty
82 */
Russ Gorbybcd5abe2011-06-16 14:20:12 -070083#define MAX_MRU 1500
84#define MAX_MTU 1500
85#define GSM_NET_TX_TIMEOUT (HZ*10)
86
87/**
88 * struct gsm_mux_net - network interface
89 * @struct gsm_dlci* dlci
90 * @struct net_device_stats stats;
91 *
92 * Created when net interface is initialized.
93 **/
94struct gsm_mux_net {
95 struct kref ref;
96 struct gsm_dlci *dlci;
97 struct net_device_stats stats;
98};
99
100#define STATS(net) (((struct gsm_mux_net *)netdev_priv(net))->stats)
Alan Coxe1eaea42010-03-26 11:32:54 +0000101
102/*
103 * Each block of data we have queued to go out is in the form of
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300104 * a gsm_msg which holds everything we need in a link layer independent
Alan Coxe1eaea42010-03-26 11:32:54 +0000105 * format
106 */
107
108struct gsm_msg {
109 struct gsm_msg *next;
110 u8 addr; /* DLCI address + flags */
111 u8 ctrl; /* Control byte + flags */
112 unsigned int len; /* Length of data block (can be zero) */
113 unsigned char *data; /* Points into buffer but not at the start */
114 unsigned char buffer[0];
115};
116
117/*
118 * Each active data link has a gsm_dlci structure associated which ties
119 * the link layer to an optional tty (if the tty side is open). To avoid
120 * complexity right now these are only ever freed up when the mux is
121 * shut down.
122 *
123 * At the moment we don't free DLCI objects until the mux is torn down
124 * this avoid object life time issues but might be worth review later.
125 */
126
127struct gsm_dlci {
128 struct gsm_mux *gsm;
129 int addr;
130 int state;
131#define DLCI_CLOSED 0
132#define DLCI_OPENING 1 /* Sending SABM not seen UA */
133#define DLCI_OPEN 2 /* SABM/UA complete */
134#define DLCI_CLOSING 3 /* Sending DISC not seen UA/DM */
Russ Gorby6ab8fba2011-06-16 14:20:13 -0700135 struct kref ref; /* freed from port or mux close */
Russ Gorbybcd5abe2011-06-16 14:20:12 -0700136 struct mutex mutex;
Alan Coxe1eaea42010-03-26 11:32:54 +0000137
138 /* Link layer */
139 spinlock_t lock; /* Protects the internal state */
140 struct timer_list t1; /* Retransmit timer for SABM and UA */
141 int retries;
142 /* Uplink tty if active */
143 struct tty_port port; /* The tty bound to this DLCI if there is one */
144 struct kfifo *fifo; /* Queue fifo for the DLCI */
145 struct kfifo _fifo; /* For new fifo API porting only */
146 int adaption; /* Adaption layer in use */
Russ Gorbybcd5abe2011-06-16 14:20:12 -0700147 int prev_adaption;
Alan Coxe1eaea42010-03-26 11:32:54 +0000148 u32 modem_rx; /* Our incoming virtual modem lines */
149 u32 modem_tx; /* Our outgoing modem lines */
150 int dead; /* Refuse re-open */
151 /* Flow control */
152 int throttled; /* Private copy of throttle state */
153 int constipated; /* Throttle status for outgoing */
154 /* Packetised I/O */
155 struct sk_buff *skb; /* Frame being sent */
156 struct sk_buff_head skb_list; /* Queued frames */
157 /* Data handling callback */
158 void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
Russ Gorbybcd5abe2011-06-16 14:20:12 -0700159 void (*prev_data)(struct gsm_dlci *dlci, u8 *data, int len);
160 struct net_device *net; /* network interface, if created */
Alan Coxe1eaea42010-03-26 11:32:54 +0000161};
162
163/* DLCI 0, 62/63 are special or reseved see gsmtty_open */
164
165#define NUM_DLCI 64
166
167/*
168 * DLCI 0 is used to pass control blocks out of band of the data
169 * flow (and with a higher link priority). One command can be outstanding
170 * at a time and we use this structure to manage them. They are created
171 * and destroyed by the user context, and updated by the receive paths
172 * and timers
173 */
174
175struct gsm_control {
176 u8 cmd; /* Command we are issuing */
177 u8 *data; /* Data for the command in case we retransmit */
178 int len; /* Length of block for retransmission */
179 int done; /* Done flag */
180 int error; /* Error if any */
181};
182
183/*
184 * Each GSM mux we have is represented by this structure. If we are
185 * operating as an ldisc then we use this structure as our ldisc
186 * state. We need to sort out lifetimes and locking with respect
187 * to the gsm mux array. For now we don't free DLCI objects that
188 * have been instantiated until the mux itself is terminated.
189 *
190 * To consider further: tty open versus mux shutdown.
191 */
192
193struct gsm_mux {
194 struct tty_struct *tty; /* The tty our ldisc is bound to */
195 spinlock_t lock;
Russ Gorbyd50f6dc2011-06-14 13:35:32 -0700196 unsigned int num;
Russ Gorby6ab8fba2011-06-16 14:20:13 -0700197 struct kref ref;
Alan Coxe1eaea42010-03-26 11:32:54 +0000198
199 /* Events on the GSM channel */
200 wait_queue_head_t event;
201
202 /* Bits for GSM mode decoding */
203
204 /* Framing Layer */
205 unsigned char *buf;
206 int state;
207#define GSM_SEARCH 0
208#define GSM_START 1
209#define GSM_ADDRESS 2
210#define GSM_CONTROL 3
211#define GSM_LEN 4
212#define GSM_DATA 5
213#define GSM_FCS 6
214#define GSM_OVERRUN 7
Alan Coxc2f2f002010-11-04 15:17:03 +0000215#define GSM_LEN0 8
216#define GSM_LEN1 9
217#define GSM_SSOF 10
Alan Coxe1eaea42010-03-26 11:32:54 +0000218 unsigned int len;
219 unsigned int address;
220 unsigned int count;
221 int escape;
222 int encoding;
223 u8 control;
224 u8 fcs;
Alan Coxc2f2f002010-11-04 15:17:03 +0000225 u8 received_fcs;
Alan Coxe1eaea42010-03-26 11:32:54 +0000226 u8 *txframe; /* TX framing buffer */
227
228 /* Methods for the receiver side */
229 void (*receive)(struct gsm_mux *gsm, u8 ch);
230 void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
231 /* And transmit side */
232 int (*output)(struct gsm_mux *mux, u8 *data, int len);
233
234 /* Link Layer */
235 unsigned int mru;
236 unsigned int mtu;
237 int initiator; /* Did we initiate connection */
238 int dead; /* Has the mux been shut down */
239 struct gsm_dlci *dlci[NUM_DLCI];
240 int constipated; /* Asked by remote to shut up */
241
242 spinlock_t tx_lock;
243 unsigned int tx_bytes; /* TX data outstanding */
244#define TX_THRESH_HI 8192
245#define TX_THRESH_LO 2048
246 struct gsm_msg *tx_head; /* Pending data packets */
247 struct gsm_msg *tx_tail;
248
249 /* Control messages */
250 struct timer_list t2_timer; /* Retransmit timer for commands */
251 int cretries; /* Command retry counter */
252 struct gsm_control *pending_cmd;/* Our current pending command */
253 spinlock_t control_lock; /* Protects the pending command */
254
255 /* Configuration */
256 int adaption; /* 1 or 2 supported */
257 u8 ftype; /* UI or UIH */
258 int t1, t2; /* Timers in 1/100th of a sec */
259 int n2; /* Retry count */
260
261 /* Statistics (not currently exposed) */
262 unsigned long bad_fcs;
263 unsigned long malformed;
264 unsigned long io_error;
265 unsigned long bad_size;
266 unsigned long unsupported;
267};
268
269
270/*
271 * Mux objects - needed so that we can translate a tty index into the
272 * relevant mux and DLCI.
273 */
274
275#define MAX_MUX 4 /* 256 minors */
276static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */
277static spinlock_t gsm_mux_lock;
278
Russ Gorbyd50f6dc2011-06-14 13:35:32 -0700279static struct tty_driver *gsm_tty_driver;
280
Alan Coxe1eaea42010-03-26 11:32:54 +0000281/*
282 * This section of the driver logic implements the GSM encodings
283 * both the basic and the 'advanced'. Reliable transport is not
284 * supported.
285 */
286
287#define CR 0x02
288#define EA 0x01
289#define PF 0x10
290
291/* I is special: the rest are ..*/
292#define RR 0x01
293#define UI 0x03
294#define RNR 0x05
295#define REJ 0x09
296#define DM 0x0F
297#define SABM 0x2F
298#define DISC 0x43
299#define UA 0x63
300#define UIH 0xEF
301
302/* Channel commands */
303#define CMD_NSC 0x09
304#define CMD_TEST 0x11
305#define CMD_PSC 0x21
306#define CMD_RLS 0x29
307#define CMD_FCOFF 0x31
308#define CMD_PN 0x41
309#define CMD_RPN 0x49
310#define CMD_FCON 0x51
311#define CMD_CLD 0x61
312#define CMD_SNC 0x69
313#define CMD_MSC 0x71
314
315/* Virtual modem bits */
316#define MDM_FC 0x01
317#define MDM_RTC 0x02
318#define MDM_RTR 0x04
319#define MDM_IC 0x20
320#define MDM_DV 0x40
321
322#define GSM0_SOF 0xF9
Alan Cox5f9a31d2010-11-04 15:17:27 +0000323#define GSM1_SOF 0x7E
Alan Coxe1eaea42010-03-26 11:32:54 +0000324#define GSM1_ESCAPE 0x7D
325#define GSM1_ESCAPE_BITS 0x20
326#define XON 0x11
327#define XOFF 0x13
328
329static const struct tty_port_operations gsm_port_ops;
330
331/*
332 * CRC table for GSM 0710
333 */
334
335static const u8 gsm_fcs8[256] = {
336 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
337 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
338 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
339 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
340 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
341 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
342 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
343 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
344 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
345 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
346 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
347 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
348 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
349 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
350 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
351 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
352 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
353 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
354 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
355 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
356 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
357 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
358 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
359 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
360 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
361 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
362 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
363 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
364 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
365 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
366 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
367 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
368};
369
370#define INIT_FCS 0xFF
371#define GOOD_FCS 0xCF
372
373/**
374 * gsm_fcs_add - update FCS
375 * @fcs: Current FCS
376 * @c: Next data
377 *
378 * Update the FCS to include c. Uses the algorithm in the specification
379 * notes.
380 */
381
382static inline u8 gsm_fcs_add(u8 fcs, u8 c)
383{
384 return gsm_fcs8[fcs ^ c];
385}
386
387/**
388 * gsm_fcs_add_block - update FCS for a block
389 * @fcs: Current FCS
390 * @c: buffer of data
391 * @len: length of buffer
392 *
393 * Update the FCS to include c. Uses the algorithm in the specification
394 * notes.
395 */
396
397static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
398{
399 while (len--)
400 fcs = gsm_fcs8[fcs ^ *c++];
401 return fcs;
402}
403
404/**
405 * gsm_read_ea - read a byte into an EA
406 * @val: variable holding value
407 * c: byte going into the EA
408 *
409 * Processes one byte of an EA. Updates the passed variable
410 * and returns 1 if the EA is now completely read
411 */
412
413static int gsm_read_ea(unsigned int *val, u8 c)
414{
415 /* Add the next 7 bits into the value */
416 *val <<= 7;
417 *val |= c >> 1;
418 /* Was this the last byte of the EA 1 = yes*/
419 return c & EA;
420}
421
422/**
423 * gsm_encode_modem - encode modem data bits
424 * @dlci: DLCI to encode from
425 *
426 * Returns the correct GSM encoded modem status bits (6 bit field) for
427 * the current status of the DLCI and attached tty object
428 */
429
430static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
431{
432 u8 modembits = 0;
433 /* FC is true flow control not modem bits */
434 if (dlci->throttled)
435 modembits |= MDM_FC;
436 if (dlci->modem_tx & TIOCM_DTR)
437 modembits |= MDM_RTC;
438 if (dlci->modem_tx & TIOCM_RTS)
439 modembits |= MDM_RTR;
440 if (dlci->modem_tx & TIOCM_RI)
441 modembits |= MDM_IC;
442 if (dlci->modem_tx & TIOCM_CD)
443 modembits |= MDM_DV;
444 return modembits;
445}
446
447/**
448 * gsm_print_packet - display a frame for debug
449 * @hdr: header to print before decode
450 * @addr: address EA from the frame
451 * @cr: C/R bit from the frame
452 * @control: control including PF bit
453 * @data: following data bytes
454 * @dlen: length of data
455 *
456 * Displays a packet in human readable format for debugging purposes. The
457 * style is based on amateur radio LAP-B dump display.
458 */
459
460static void gsm_print_packet(const char *hdr, int addr, int cr,
461 u8 control, const u8 *data, int dlen)
462{
463 if (!(debug & 1))
464 return;
465
Alan Cox5f9a31d2010-11-04 15:17:27 +0000466 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
Alan Coxe1eaea42010-03-26 11:32:54 +0000467
468 switch (control & ~PF) {
469 case SABM:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000470 pr_cont("SABM");
Alan Coxe1eaea42010-03-26 11:32:54 +0000471 break;
472 case UA:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000473 pr_cont("UA");
Alan Coxe1eaea42010-03-26 11:32:54 +0000474 break;
475 case DISC:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000476 pr_cont("DISC");
Alan Coxe1eaea42010-03-26 11:32:54 +0000477 break;
478 case DM:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000479 pr_cont("DM");
Alan Coxe1eaea42010-03-26 11:32:54 +0000480 break;
481 case UI:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000482 pr_cont("UI");
Alan Coxe1eaea42010-03-26 11:32:54 +0000483 break;
484 case UIH:
Alan Cox5f9a31d2010-11-04 15:17:27 +0000485 pr_cont("UIH");
Alan Coxe1eaea42010-03-26 11:32:54 +0000486 break;
487 default:
488 if (!(control & 0x01)) {
Alan Cox5f9a31d2010-11-04 15:17:27 +0000489 pr_cont("I N(S)%d N(R)%d",
490 (control & 0x0E) >> 1, (control & 0xE) >> 5);
Alan Coxe1eaea42010-03-26 11:32:54 +0000491 } else switch (control & 0x0F) {
Alan Cox5f9a31d2010-11-04 15:17:27 +0000492 case RR:
493 pr_cont("RR(%d)", (control & 0xE0) >> 5);
494 break;
495 case RNR:
496 pr_cont("RNR(%d)", (control & 0xE0) >> 5);
497 break;
498 case REJ:
499 pr_cont("REJ(%d)", (control & 0xE0) >> 5);
500 break;
501 default:
502 pr_cont("[%02X]", control);
Alan Coxe1eaea42010-03-26 11:32:54 +0000503 }
504 }
505
506 if (control & PF)
Alan Cox5f9a31d2010-11-04 15:17:27 +0000507 pr_cont("(P)");
Alan Coxe1eaea42010-03-26 11:32:54 +0000508 else
Alan Cox5f9a31d2010-11-04 15:17:27 +0000509 pr_cont("(F)");
Alan Coxe1eaea42010-03-26 11:32:54 +0000510
511 if (dlen) {
512 int ct = 0;
513 while (dlen--) {
Alan Cox5f9a31d2010-11-04 15:17:27 +0000514 if (ct % 8 == 0) {
515 pr_cont("\n");
516 pr_debug(" ");
517 }
518 pr_cont("%02X ", *data++);
Alan Coxe1eaea42010-03-26 11:32:54 +0000519 ct++;
520 }
521 }
Alan Cox5f9a31d2010-11-04 15:17:27 +0000522 pr_cont("\n");
Alan Coxe1eaea42010-03-26 11:32:54 +0000523}
524
525
526/*
527 * Link level transmission side
528 */
529
530/**
531 * gsm_stuff_packet - bytestuff a packet
532 * @ibuf: input
533 * @obuf: output
534 * @len: length of input
535 *
536 * Expand a buffer by bytestuffing it. The worst case size change
537 * is doubling and the caller is responsible for handing out
538 * suitable sized buffers.
539 */
540
541static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
542{
543 int olen = 0;
544 while (len--) {
545 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
546 || *input == XON || *input == XOFF) {
547 *output++ = GSM1_ESCAPE;
548 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
549 olen++;
550 } else
551 *output++ = *input++;
552 olen++;
553 }
554 return olen;
555}
556
Alan Coxe1eaea42010-03-26 11:32:54 +0000557/**
558 * gsm_send - send a control frame
559 * @gsm: our GSM mux
560 * @addr: address for control frame
561 * @cr: command/response bit
562 * @control: control byte including PF bit
563 *
564 * Format up and transmit a control frame. These do not go via the
565 * queueing logic as they should be transmitted ahead of data when
566 * they are needed.
567 *
568 * FIXME: Lock versus data TX path
569 */
570
571static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
572{
573 int len;
574 u8 cbuf[10];
575 u8 ibuf[3];
576
577 switch (gsm->encoding) {
578 case 0:
579 cbuf[0] = GSM0_SOF;
580 cbuf[1] = (addr << 2) | (cr << 1) | EA;
581 cbuf[2] = control;
582 cbuf[3] = EA; /* Length of data = 0 */
583 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
584 cbuf[5] = GSM0_SOF;
585 len = 6;
586 break;
587 case 1:
588 case 2:
589 /* Control frame + packing (but not frame stuffing) in mode 1 */
590 ibuf[0] = (addr << 2) | (cr << 1) | EA;
591 ibuf[1] = control;
592 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
593 /* Stuffing may double the size worst case */
594 len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
595 /* Now add the SOF markers */
596 cbuf[0] = GSM1_SOF;
597 cbuf[len + 1] = GSM1_SOF;
598 /* FIXME: we can omit the lead one in many cases */
599 len += 2;
600 break;
601 default:
602 WARN_ON(1);
603 return;
604 }
605 gsm->output(gsm, cbuf, len);
606 gsm_print_packet("-->", addr, cr, control, NULL, 0);
607}
608
609/**
610 * gsm_response - send a control response
611 * @gsm: our GSM mux
612 * @addr: address for control frame
613 * @control: control byte including PF bit
614 *
615 * Format up and transmit a link level response frame.
616 */
617
618static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
619{
620 gsm_send(gsm, addr, 0, control);
621}
622
623/**
624 * gsm_command - send a control command
625 * @gsm: our GSM mux
626 * @addr: address for control frame
627 * @control: control byte including PF bit
628 *
629 * Format up and transmit a link level command frame.
630 */
631
632static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
633{
634 gsm_send(gsm, addr, 1, control);
635}
636
637/* Data transmission */
638
639#define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
640
641/**
642 * gsm_data_alloc - allocate data frame
643 * @gsm: GSM mux
644 * @addr: DLCI address
645 * @len: length excluding header and FCS
646 * @ctrl: control byte
647 *
648 * Allocate a new data buffer for sending frames with data. Space is left
649 * at the front for header bytes but that is treated as an implementation
650 * detail and not for the high level code to use
651 */
652
653static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
654 u8 ctrl)
655{
656 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
657 GFP_ATOMIC);
658 if (m == NULL)
659 return NULL;
660 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */
661 m->len = len;
662 m->addr = addr;
663 m->ctrl = ctrl;
664 m->next = NULL;
665 return m;
666}
667
668/**
669 * gsm_data_kick - poke the queue
670 * @gsm: GSM Mux
671 *
672 * The tty device has called us to indicate that room has appeared in
673 * the transmit queue. Ram more data into the pipe if we have any
674 *
675 * FIXME: lock against link layer control transmissions
676 */
677
678static void gsm_data_kick(struct gsm_mux *gsm)
679{
680 struct gsm_msg *msg = gsm->tx_head;
681 int len;
682 int skip_sof = 0;
683
684 /* FIXME: We need to apply this solely to data messages */
685 if (gsm->constipated)
686 return;
687
688 while (gsm->tx_head != NULL) {
689 msg = gsm->tx_head;
690 if (gsm->encoding != 0) {
691 gsm->txframe[0] = GSM1_SOF;
692 len = gsm_stuff_frame(msg->data,
693 gsm->txframe + 1, msg->len);
694 gsm->txframe[len + 1] = GSM1_SOF;
695 len += 2;
696 } else {
697 gsm->txframe[0] = GSM0_SOF;
698 memcpy(gsm->txframe + 1 , msg->data, msg->len);
699 gsm->txframe[msg->len + 1] = GSM0_SOF;
700 len = msg->len + 2;
701 }
702
Joe Perches0a77c4f2011-04-25 16:46:49 -0700703 if (debug & 4)
704 print_hex_dump_bytes("gsm_data_kick: ",
705 DUMP_PREFIX_OFFSET,
706 gsm->txframe, len);
Alan Coxe1eaea42010-03-26 11:32:54 +0000707
708 if (gsm->output(gsm, gsm->txframe + skip_sof,
709 len - skip_sof) < 0)
710 break;
711 /* FIXME: Can eliminate one SOF in many more cases */
712 gsm->tx_head = msg->next;
713 if (gsm->tx_head == NULL)
714 gsm->tx_tail = NULL;
715 gsm->tx_bytes -= msg->len;
716 kfree(msg);
717 /* For a burst of frames skip the extra SOF within the
718 burst */
719 skip_sof = 1;
720 }
721}
722
723/**
724 * __gsm_data_queue - queue a UI or UIH frame
725 * @dlci: DLCI sending the data
726 * @msg: message queued
727 *
728 * Add data to the transmit queue and try and get stuff moving
729 * out of the mux tty if not already doing so. The Caller must hold
730 * the gsm tx lock.
731 */
732
733static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
734{
735 struct gsm_mux *gsm = dlci->gsm;
736 u8 *dp = msg->data;
737 u8 *fcs = dp + msg->len;
738
739 /* Fill in the header */
740 if (gsm->encoding == 0) {
741 if (msg->len < 128)
742 *--dp = (msg->len << 1) | EA;
743 else {
Ken Millsbe7a7412010-12-13 15:27:27 +0000744 *--dp = (msg->len >> 7); /* bits 7 - 15 */
745 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */
Alan Coxe1eaea42010-03-26 11:32:54 +0000746 }
747 }
748
749 *--dp = msg->ctrl;
750 if (gsm->initiator)
751 *--dp = (msg->addr << 2) | 2 | EA;
752 else
753 *--dp = (msg->addr << 2) | EA;
754 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
755 /* Ugly protocol layering violation */
756 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
757 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
758 *fcs = 0xFF - *fcs;
759
760 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
761 msg->data, msg->len);
762
763 /* Move the header back and adjust the length, also allow for the FCS
764 now tacked on the end */
765 msg->len += (msg->data - dp) + 1;
766 msg->data = dp;
767
768 /* Add to the actual output queue */
769 if (gsm->tx_tail)
770 gsm->tx_tail->next = msg;
771 else
772 gsm->tx_head = msg;
773 gsm->tx_tail = msg;
774 gsm->tx_bytes += msg->len;
775 gsm_data_kick(gsm);
776}
777
778/**
779 * gsm_data_queue - queue a UI or UIH frame
780 * @dlci: DLCI sending the data
781 * @msg: message queued
782 *
783 * Add data to the transmit queue and try and get stuff moving
784 * out of the mux tty if not already doing so. Take the
785 * the gsm tx lock and dlci lock.
786 */
787
788static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
789{
790 unsigned long flags;
791 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
792 __gsm_data_queue(dlci, msg);
793 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
794}
795
796/**
797 * gsm_dlci_data_output - try and push data out of a DLCI
798 * @gsm: mux
799 * @dlci: the DLCI to pull data from
800 *
801 * Pull data from a DLCI and send it into the transmit queue if there
802 * is data. Keep to the MRU of the mux. This path handles the usual tty
803 * interface which is a byte stream with optional modem data.
804 *
805 * Caller must hold the tx_lock of the mux.
806 */
807
808static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
809{
810 struct gsm_msg *msg;
811 u8 *dp;
Mikhail Kshevetskiy268e5262011-09-23 19:22:56 +0400812 int len, total_size, size;
Alan Coxe1eaea42010-03-26 11:32:54 +0000813 int h = dlci->adaption - 1;
814
Mikhail Kshevetskiy268e5262011-09-23 19:22:56 +0400815 total_size = 0;
816 while(1) {
817 len = kfifo_len(dlci->fifo);
818 if (len == 0)
819 return total_size;
Alan Coxe1eaea42010-03-26 11:32:54 +0000820
Mikhail Kshevetskiy268e5262011-09-23 19:22:56 +0400821 /* MTU/MRU count only the data bits */
822 if (len > gsm->mtu)
823 len = gsm->mtu;
Alan Coxe1eaea42010-03-26 11:32:54 +0000824
Mikhail Kshevetskiy268e5262011-09-23 19:22:56 +0400825 size = len + h;
Alan Coxe1eaea42010-03-26 11:32:54 +0000826
Mikhail Kshevetskiy268e5262011-09-23 19:22:56 +0400827 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
828 /* FIXME: need a timer or something to kick this so it can't
829 get stuck with no work outstanding and no buffer free */
830 if (msg == NULL)
831 return -ENOMEM;
832 dp = msg->data;
833 switch (dlci->adaption) {
834 case 1: /* Unstructured */
835 break;
836 case 2: /* Unstructed with modem bits. Always one byte as we never
837 send inline break data */
838 *dp++ = gsm_encode_modem(dlci);
839 break;
840 }
841 WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
842 __gsm_data_queue(dlci, msg);
843 total_size += size;
Alan Coxe1eaea42010-03-26 11:32:54 +0000844 }
Alan Coxe1eaea42010-03-26 11:32:54 +0000845 /* Bytes of data we used up */
Mikhail Kshevetskiy268e5262011-09-23 19:22:56 +0400846 return total_size;
Alan Coxe1eaea42010-03-26 11:32:54 +0000847}
848
849/**
850 * gsm_dlci_data_output_framed - try and push data out of a DLCI
851 * @gsm: mux
852 * @dlci: the DLCI to pull data from
853 *
854 * Pull data from a DLCI and send it into the transmit queue if there
855 * is data. Keep to the MRU of the mux. This path handles framed data
856 * queued as skbuffs to the DLCI.
857 *
858 * Caller must hold the tx_lock of the mux.
859 */
860
861static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
862 struct gsm_dlci *dlci)
863{
864 struct gsm_msg *msg;
865 u8 *dp;
866 int len, size;
867 int last = 0, first = 0;
868 int overhead = 0;
869
870 /* One byte per frame is used for B/F flags */
871 if (dlci->adaption == 4)
872 overhead = 1;
873
874 /* dlci->skb is locked by tx_lock */
875 if (dlci->skb == NULL) {
876 dlci->skb = skb_dequeue(&dlci->skb_list);
877 if (dlci->skb == NULL)
878 return 0;
879 first = 1;
880 }
881 len = dlci->skb->len + overhead;
882
883 /* MTU/MRU count only the data bits */
884 if (len > gsm->mtu) {
885 if (dlci->adaption == 3) {
886 /* Over long frame, bin it */
887 kfree_skb(dlci->skb);
888 dlci->skb = NULL;
889 return 0;
890 }
891 len = gsm->mtu;
892 } else
893 last = 1;
894
895 size = len + overhead;
896 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
897
898 /* FIXME: need a timer or something to kick this so it can't
899 get stuck with no work outstanding and no buffer free */
900 if (msg == NULL)
901 return -ENOMEM;
902 dp = msg->data;
903
904 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
905 /* Flag byte to carry the start/end info */
906 *dp++ = last << 7 | first << 6 | 1; /* EA */
907 len--;
908 }
Russ Gorby57f21042011-06-14 13:23:29 -0700909 memcpy(dp, dlci->skb->data, len);
910 skb_pull(dlci->skb, len);
Alan Coxe1eaea42010-03-26 11:32:54 +0000911 __gsm_data_queue(dlci, msg);
Russ Gorbybcd5abe2011-06-16 14:20:12 -0700912 if (last) {
913 kfree_skb(dlci->skb);
Alan Coxe1eaea42010-03-26 11:32:54 +0000914 dlci->skb = NULL;
Russ Gorbybcd5abe2011-06-16 14:20:12 -0700915 }
Alan Coxe1eaea42010-03-26 11:32:54 +0000916 return size;
917}
918
919/**
920 * gsm_dlci_data_sweep - look for data to send
921 * @gsm: the GSM mux
922 *
923 * Sweep the GSM mux channels in priority order looking for ones with
924 * data to send. We could do with optimising this scan a bit. We aim
925 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
926 * TX_THRESH_LO we get called again
927 *
928 * FIXME: We should round robin between groups and in theory you can
929 * renegotiate DLCI priorities with optional stuff. Needs optimising.
930 */
931
932static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
933{
934 int len;
935 /* Priority ordering: We should do priority with RR of the groups */
936 int i = 1;
Alan Coxe1eaea42010-03-26 11:32:54 +0000937
Alan Coxe1eaea42010-03-26 11:32:54 +0000938 while (i < NUM_DLCI) {
939 struct gsm_dlci *dlci;
940
941 if (gsm->tx_bytes > TX_THRESH_HI)
942 break;
943 dlci = gsm->dlci[i];
944 if (dlci == NULL || dlci->constipated) {
945 i++;
946 continue;
947 }
Russ Gorbybcd5abe2011-06-16 14:20:12 -0700948 if (dlci->adaption < 3 && !dlci->net)
Alan Coxe1eaea42010-03-26 11:32:54 +0000949 len = gsm_dlci_data_output(gsm, dlci);
950 else
951 len = gsm_dlci_data_output_framed(gsm, dlci);
952 if (len < 0)
Julia Lawalle73790a2010-08-10 18:03:12 -0700953 break;
Alan Coxe1eaea42010-03-26 11:32:54 +0000954 /* DLCI empty - try the next */
955 if (len == 0)
956 i++;
957 }
Alan Coxe1eaea42010-03-26 11:32:54 +0000958}
959
960/**
961 * gsm_dlci_data_kick - transmit if possible
962 * @dlci: DLCI to kick
963 *
964 * Transmit data from this DLCI if the queue is empty. We can't rely on
965 * a tty wakeup except when we filled the pipe so we need to fire off
966 * new data ourselves in other cases.
967 */
968
969static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
970{
971 unsigned long flags;
972
973 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
974 /* If we have nothing running then we need to fire up */
Russ Gorbybcd5abe2011-06-16 14:20:12 -0700975 if (dlci->gsm->tx_bytes == 0) {
976 if (dlci->net)
977 gsm_dlci_data_output_framed(dlci->gsm, dlci);
978 else
979 gsm_dlci_data_output(dlci->gsm, dlci);
980 } else if (dlci->gsm->tx_bytes < TX_THRESH_LO)
Alan Coxe1eaea42010-03-26 11:32:54 +0000981 gsm_dlci_data_sweep(dlci->gsm);
982 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
983}
984
985/*
986 * Control message processing
987 */
988
989
990/**
991 * gsm_control_reply - send a response frame to a control
992 * @gsm: gsm channel
993 * @cmd: the command to use
994 * @data: data to follow encoded info
995 * @dlen: length of data
996 *
997 * Encode up and queue a UI/UIH frame containing our response.
998 */
999
1000static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
1001 int dlen)
1002{
1003 struct gsm_msg *msg;
1004 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
Ken Mills093d8042010-12-13 15:28:03 +00001005 if (msg == NULL)
1006 return;
Alan Coxe1eaea42010-03-26 11:32:54 +00001007 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */
1008 msg->data[1] = (dlen << 1) | EA;
1009 memcpy(msg->data + 2, data, dlen);
1010 gsm_data_queue(gsm->dlci[0], msg);
1011}
1012
1013/**
1014 * gsm_process_modem - process received modem status
1015 * @tty: virtual tty bound to the DLCI
1016 * @dlci: DLCI to affect
1017 * @modem: modem bits (full EA)
1018 *
1019 * Used when a modem control message or line state inline in adaption
1020 * layer 2 is processed. Sort out the local modem state and throttles
1021 */
1022
1023static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
Russ Gorby72632872011-06-14 13:23:28 -07001024 u32 modem, int clen)
Alan Coxe1eaea42010-03-26 11:32:54 +00001025{
1026 int mlines = 0;
Russ Gorby72632872011-06-14 13:23:28 -07001027 u8 brk = 0;
1028
1029 /* The modem status command can either contain one octet (v.24 signals)
1030 or two octets (v.24 signals + break signals). The length field will
1031 either be 2 or 3 respectively. This is specified in section
1032 5.4.6.3.7 of the 27.010 mux spec. */
1033
1034 if (clen == 2)
1035 modem = modem & 0x7f;
1036 else {
1037 brk = modem & 0x7f;
1038 modem = (modem >> 7) & 0x7f;
1039 };
Alan Coxe1eaea42010-03-26 11:32:54 +00001040
1041 /* Flow control/ready to communicate */
1042 if (modem & MDM_FC) {
1043 /* Need to throttle our output on this device */
1044 dlci->constipated = 1;
1045 }
1046 if (modem & MDM_RTC) {
1047 mlines |= TIOCM_DSR | TIOCM_DTR;
1048 dlci->constipated = 0;
1049 gsm_dlci_data_kick(dlci);
1050 }
1051 /* Map modem bits */
1052 if (modem & MDM_RTR)
1053 mlines |= TIOCM_RTS | TIOCM_CTS;
1054 if (modem & MDM_IC)
1055 mlines |= TIOCM_RI;
1056 if (modem & MDM_DV)
1057 mlines |= TIOCM_CD;
1058
1059 /* Carrier drop -> hangup */
1060 if (tty) {
1061 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1062 if (!(tty->termios->c_cflag & CLOCAL))
1063 tty_hangup(tty);
1064 if (brk & 0x01)
1065 tty_insert_flip_char(tty, 0, TTY_BREAK);
1066 }
1067 dlci->modem_rx = mlines;
1068}
1069
1070/**
1071 * gsm_control_modem - modem status received
1072 * @gsm: GSM channel
1073 * @data: data following command
1074 * @clen: command length
1075 *
1076 * We have received a modem status control message. This is used by
1077 * the GSM mux protocol to pass virtual modem line status and optionally
1078 * to indicate break signals. Unpack it, convert to Linux representation
1079 * and if need be stuff a break message down the tty.
1080 */
1081
1082static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1083{
1084 unsigned int addr = 0;
1085 unsigned int modem = 0;
1086 struct gsm_dlci *dlci;
1087 int len = clen;
1088 u8 *dp = data;
1089 struct tty_struct *tty;
1090
1091 while (gsm_read_ea(&addr, *dp++) == 0) {
1092 len--;
1093 if (len == 0)
1094 return;
1095 }
1096 /* Must be at least one byte following the EA */
1097 len--;
1098 if (len <= 0)
1099 return;
1100
1101 addr >>= 1;
1102 /* Closed port, or invalid ? */
1103 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1104 return;
1105 dlci = gsm->dlci[addr];
1106
1107 while (gsm_read_ea(&modem, *dp++) == 0) {
1108 len--;
1109 if (len == 0)
1110 return;
1111 }
1112 tty = tty_port_tty_get(&dlci->port);
Russ Gorby72632872011-06-14 13:23:28 -07001113 gsm_process_modem(tty, dlci, modem, clen);
Alan Coxe1eaea42010-03-26 11:32:54 +00001114 if (tty) {
1115 tty_wakeup(tty);
1116 tty_kref_put(tty);
1117 }
1118 gsm_control_reply(gsm, CMD_MSC, data, clen);
1119}
1120
1121/**
1122 * gsm_control_rls - remote line status
1123 * @gsm: GSM channel
1124 * @data: data bytes
1125 * @clen: data length
1126 *
1127 * The modem sends us a two byte message on the control channel whenever
1128 * it wishes to send us an error state from the virtual link. Stuff
1129 * this into the uplink tty if present
1130 */
1131
1132static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1133{
1134 struct tty_struct *tty;
1135 unsigned int addr = 0 ;
1136 u8 bits;
1137 int len = clen;
1138 u8 *dp = data;
1139
1140 while (gsm_read_ea(&addr, *dp++) == 0) {
1141 len--;
1142 if (len == 0)
1143 return;
1144 }
1145 /* Must be at least one byte following ea */
1146 len--;
1147 if (len <= 0)
1148 return;
1149 addr >>= 1;
1150 /* Closed port, or invalid ? */
1151 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1152 return;
1153 /* No error ? */
1154 bits = *dp;
1155 if ((bits & 1) == 0)
1156 return;
1157 /* See if we have an uplink tty */
1158 tty = tty_port_tty_get(&gsm->dlci[addr]->port);
1159
1160 if (tty) {
1161 if (bits & 2)
1162 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1163 if (bits & 4)
1164 tty_insert_flip_char(tty, 0, TTY_PARITY);
1165 if (bits & 8)
1166 tty_insert_flip_char(tty, 0, TTY_FRAME);
1167 tty_flip_buffer_push(tty);
1168 tty_kref_put(tty);
1169 }
1170 gsm_control_reply(gsm, CMD_RLS, data, clen);
1171}
1172
1173static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1174
1175/**
1176 * gsm_control_message - DLCI 0 control processing
1177 * @gsm: our GSM mux
1178 * @command: the command EA
1179 * @data: data beyond the command/length EAs
1180 * @clen: length
1181 *
1182 * Input processor for control messages from the other end of the link.
1183 * Processes the incoming request and queues a response frame or an
1184 * NSC response if not supported
1185 */
1186
1187static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1188 u8 *data, int clen)
1189{
1190 u8 buf[1];
1191 switch (command) {
1192 case CMD_CLD: {
1193 struct gsm_dlci *dlci = gsm->dlci[0];
1194 /* Modem wishes to close down */
1195 if (dlci) {
1196 dlci->dead = 1;
1197 gsm->dead = 1;
1198 gsm_dlci_begin_close(dlci);
1199 }
1200 }
1201 break;
1202 case CMD_TEST:
1203 /* Modem wishes to test, reply with the data */
1204 gsm_control_reply(gsm, CMD_TEST, data, clen);
1205 break;
1206 case CMD_FCON:
1207 /* Modem wants us to STFU */
1208 gsm->constipated = 1;
1209 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1210 break;
1211 case CMD_FCOFF:
1212 /* Modem can accept data again */
1213 gsm->constipated = 0;
1214 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1215 /* Kick the link in case it is idling */
1216 gsm_data_kick(gsm);
1217 break;
1218 case CMD_MSC:
1219 /* Out of band modem line change indicator for a DLCI */
1220 gsm_control_modem(gsm, data, clen);
1221 break;
1222 case CMD_RLS:
1223 /* Out of band error reception for a DLCI */
1224 gsm_control_rls(gsm, data, clen);
1225 break;
1226 case CMD_PSC:
1227 /* Modem wishes to enter power saving state */
1228 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1229 break;
1230 /* Optional unsupported commands */
1231 case CMD_PN: /* Parameter negotiation */
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001232 case CMD_RPN: /* Remote port negotiation */
1233 case CMD_SNC: /* Service negotiation command */
Alan Coxe1eaea42010-03-26 11:32:54 +00001234 default:
1235 /* Reply to bad commands with an NSC */
1236 buf[0] = command;
1237 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1238 break;
1239 }
1240}
1241
1242/**
1243 * gsm_control_response - process a response to our control
1244 * @gsm: our GSM mux
1245 * @command: the command (response) EA
1246 * @data: data beyond the command/length EA
1247 * @clen: length
1248 *
1249 * Process a response to an outstanding command. We only allow a single
1250 * control message in flight so this is fairly easy. All the clean up
1251 * is done by the caller, we just update the fields, flag it as done
1252 * and return
1253 */
1254
1255static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1256 u8 *data, int clen)
1257{
1258 struct gsm_control *ctrl;
1259 unsigned long flags;
1260
1261 spin_lock_irqsave(&gsm->control_lock, flags);
1262
1263 ctrl = gsm->pending_cmd;
1264 /* Does the reply match our command */
1265 command |= 1;
1266 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1267 /* Our command was replied to, kill the retry timer */
1268 del_timer(&gsm->t2_timer);
1269 gsm->pending_cmd = NULL;
1270 /* Rejected by the other end */
1271 if (command == CMD_NSC)
1272 ctrl->error = -EOPNOTSUPP;
1273 ctrl->done = 1;
1274 wake_up(&gsm->event);
1275 }
1276 spin_unlock_irqrestore(&gsm->control_lock, flags);
1277}
1278
1279/**
Alan Cox5f9a31d2010-11-04 15:17:27 +00001280 * gsm_control_transmit - send control packet
Alan Coxe1eaea42010-03-26 11:32:54 +00001281 * @gsm: gsm mux
1282 * @ctrl: frame to send
1283 *
1284 * Send out a pending control command (called under control lock)
1285 */
1286
1287static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1288{
Eric Bénarded43b472011-03-09 19:24:49 +01001289 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype);
Alan Coxe1eaea42010-03-26 11:32:54 +00001290 if (msg == NULL)
1291 return;
1292 msg->data[0] = (ctrl->cmd << 1) | 2 | EA; /* command */
1293 memcpy(msg->data + 1, ctrl->data, ctrl->len);
1294 gsm_data_queue(gsm->dlci[0], msg);
1295}
1296
1297/**
1298 * gsm_control_retransmit - retransmit a control frame
1299 * @data: pointer to our gsm object
1300 *
1301 * Called off the T2 timer expiry in order to retransmit control frames
1302 * that have been lost in the system somewhere. The control_lock protects
1303 * us from colliding with another sender or a receive completion event.
1304 * In that situation the timer may still occur in a small window but
1305 * gsm->pending_cmd will be NULL and we just let the timer expire.
1306 */
1307
1308static void gsm_control_retransmit(unsigned long data)
1309{
1310 struct gsm_mux *gsm = (struct gsm_mux *)data;
1311 struct gsm_control *ctrl;
1312 unsigned long flags;
1313 spin_lock_irqsave(&gsm->control_lock, flags);
1314 ctrl = gsm->pending_cmd;
1315 if (ctrl) {
1316 gsm->cretries--;
1317 if (gsm->cretries == 0) {
1318 gsm->pending_cmd = NULL;
1319 ctrl->error = -ETIMEDOUT;
1320 ctrl->done = 1;
1321 spin_unlock_irqrestore(&gsm->control_lock, flags);
1322 wake_up(&gsm->event);
1323 return;
1324 }
1325 gsm_control_transmit(gsm, ctrl);
1326 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1327 }
1328 spin_unlock_irqrestore(&gsm->control_lock, flags);
1329}
1330
1331/**
1332 * gsm_control_send - send a control frame on DLCI 0
1333 * @gsm: the GSM channel
1334 * @command: command to send including CR bit
1335 * @data: bytes of data (must be kmalloced)
1336 * @len: length of the block to send
1337 *
1338 * Queue and dispatch a control command. Only one command can be
1339 * active at a time. In theory more can be outstanding but the matching
1340 * gets really complicated so for now stick to one outstanding.
1341 */
1342
1343static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1344 unsigned int command, u8 *data, int clen)
1345{
1346 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1347 GFP_KERNEL);
1348 unsigned long flags;
1349 if (ctrl == NULL)
1350 return NULL;
1351retry:
1352 wait_event(gsm->event, gsm->pending_cmd == NULL);
1353 spin_lock_irqsave(&gsm->control_lock, flags);
1354 if (gsm->pending_cmd != NULL) {
1355 spin_unlock_irqrestore(&gsm->control_lock, flags);
1356 goto retry;
1357 }
1358 ctrl->cmd = command;
1359 ctrl->data = data;
1360 ctrl->len = clen;
1361 gsm->pending_cmd = ctrl;
1362 gsm->cretries = gsm->n2;
1363 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1364 gsm_control_transmit(gsm, ctrl);
1365 spin_unlock_irqrestore(&gsm->control_lock, flags);
1366 return ctrl;
1367}
1368
1369/**
1370 * gsm_control_wait - wait for a control to finish
1371 * @gsm: GSM mux
1372 * @control: control we are waiting on
1373 *
1374 * Waits for the control to complete or time out. Frees any used
1375 * resources and returns 0 for success, or an error if the remote
1376 * rejected or ignored the request.
1377 */
1378
1379static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1380{
1381 int err;
1382 wait_event(gsm->event, control->done == 1);
1383 err = control->error;
1384 kfree(control);
1385 return err;
1386}
1387
1388
1389/*
1390 * DLCI level handling: Needs krefs
1391 */
1392
1393/*
1394 * State transitions and timers
1395 */
1396
1397/**
1398 * gsm_dlci_close - a DLCI has closed
1399 * @dlci: DLCI that closed
1400 *
1401 * Perform processing when moving a DLCI into closed state. If there
1402 * is an attached tty this is hung up
1403 */
1404
1405static void gsm_dlci_close(struct gsm_dlci *dlci)
1406{
1407 del_timer(&dlci->t1);
1408 if (debug & 8)
Alan Cox5f9a31d2010-11-04 15:17:27 +00001409 pr_debug("DLCI %d goes closed.\n", dlci->addr);
Alan Coxe1eaea42010-03-26 11:32:54 +00001410 dlci->state = DLCI_CLOSED;
1411 if (dlci->addr != 0) {
1412 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1413 if (tty) {
1414 tty_hangup(tty);
1415 tty_kref_put(tty);
1416 }
1417 kfifo_reset(dlci->fifo);
1418 } else
1419 dlci->gsm->dead = 1;
1420 wake_up(&dlci->gsm->event);
1421 /* A DLCI 0 close is a MUX termination so we need to kick that
1422 back to userspace somehow */
1423}
1424
1425/**
1426 * gsm_dlci_open - a DLCI has opened
1427 * @dlci: DLCI that opened
1428 *
1429 * Perform processing when moving a DLCI into open state.
1430 */
1431
1432static void gsm_dlci_open(struct gsm_dlci *dlci)
1433{
1434 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1435 open -> open */
1436 del_timer(&dlci->t1);
1437 /* This will let a tty open continue */
1438 dlci->state = DLCI_OPEN;
1439 if (debug & 8)
Alan Cox5f9a31d2010-11-04 15:17:27 +00001440 pr_debug("DLCI %d goes open.\n", dlci->addr);
Alan Coxe1eaea42010-03-26 11:32:54 +00001441 wake_up(&dlci->gsm->event);
1442}
1443
1444/**
1445 * gsm_dlci_t1 - T1 timer expiry
1446 * @dlci: DLCI that opened
1447 *
1448 * The T1 timer handles retransmits of control frames (essentially of
1449 * SABM and DISC). We resend the command until the retry count runs out
1450 * in which case an opening port goes back to closed and a closing port
1451 * is simply put into closed state (any further frames from the other
1452 * end will get a DM response)
1453 */
1454
1455static void gsm_dlci_t1(unsigned long data)
1456{
1457 struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1458 struct gsm_mux *gsm = dlci->gsm;
1459
1460 switch (dlci->state) {
1461 case DLCI_OPENING:
1462 dlci->retries--;
1463 if (dlci->retries) {
1464 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1465 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1466 } else
1467 gsm_dlci_close(dlci);
1468 break;
1469 case DLCI_CLOSING:
1470 dlci->retries--;
1471 if (dlci->retries) {
1472 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1473 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1474 } else
1475 gsm_dlci_close(dlci);
1476 break;
1477 }
1478}
1479
1480/**
1481 * gsm_dlci_begin_open - start channel open procedure
1482 * @dlci: DLCI to open
1483 *
1484 * Commence opening a DLCI from the Linux side. We issue SABM messages
1485 * to the modem which should then reply with a UA, at which point we
1486 * will move into open state. Opening is done asynchronously with retry
1487 * running off timers and the responses.
1488 */
1489
1490static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1491{
1492 struct gsm_mux *gsm = dlci->gsm;
1493 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1494 return;
1495 dlci->retries = gsm->n2;
1496 dlci->state = DLCI_OPENING;
1497 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1498 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1499}
1500
1501/**
1502 * gsm_dlci_begin_close - start channel open procedure
1503 * @dlci: DLCI to open
1504 *
1505 * Commence closing a DLCI from the Linux side. We issue DISC messages
1506 * to the modem which should then reply with a UA, at which point we
1507 * will move into closed state. Closing is done asynchronously with retry
1508 * off timers. We may also receive a DM reply from the other end which
1509 * indicates the channel was already closed.
1510 */
1511
1512static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1513{
1514 struct gsm_mux *gsm = dlci->gsm;
1515 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1516 return;
1517 dlci->retries = gsm->n2;
1518 dlci->state = DLCI_CLOSING;
1519 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1520 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1521}
1522
1523/**
1524 * gsm_dlci_data - data arrived
1525 * @dlci: channel
1526 * @data: block of bytes received
1527 * @len: length of received block
1528 *
1529 * A UI or UIH frame has arrived which contains data for a channel
1530 * other than the control channel. If the relevant virtual tty is
1531 * open we shovel the bits down it, if not we drop them.
1532 */
1533
Russ Gorby72632872011-06-14 13:23:28 -07001534static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int clen)
Alan Coxe1eaea42010-03-26 11:32:54 +00001535{
1536 /* krefs .. */
1537 struct tty_port *port = &dlci->port;
1538 struct tty_struct *tty = tty_port_tty_get(port);
1539 unsigned int modem = 0;
Russ Gorby72632872011-06-14 13:23:28 -07001540 int len = clen;
Alan Coxe1eaea42010-03-26 11:32:54 +00001541
1542 if (debug & 16)
Alan Cox5f9a31d2010-11-04 15:17:27 +00001543 pr_debug("%d bytes for tty %p\n", len, tty);
Alan Coxe1eaea42010-03-26 11:32:54 +00001544 if (tty) {
1545 switch (dlci->adaption) {
Alan Cox5f9a31d2010-11-04 15:17:27 +00001546 /* Unsupported types */
1547 /* Packetised interruptible data */
1548 case 4:
1549 break;
1550 /* Packetised uininterruptible voice/data */
1551 case 3:
1552 break;
1553 /* Asynchronous serial with line state in each frame */
1554 case 2:
1555 while (gsm_read_ea(&modem, *data++) == 0) {
1556 len--;
1557 if (len == 0)
1558 return;
1559 }
Russ Gorby72632872011-06-14 13:23:28 -07001560 gsm_process_modem(tty, dlci, modem, clen);
Alan Cox5f9a31d2010-11-04 15:17:27 +00001561 /* Line state will go via DLCI 0 controls only */
1562 case 1:
1563 default:
1564 tty_insert_flip_string(tty, data, len);
1565 tty_flip_buffer_push(tty);
Alan Coxe1eaea42010-03-26 11:32:54 +00001566 }
1567 tty_kref_put(tty);
1568 }
1569}
1570
1571/**
1572 * gsm_dlci_control - data arrived on control channel
1573 * @dlci: channel
1574 * @data: block of bytes received
1575 * @len: length of received block
1576 *
1577 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1578 * control channel. This should contain a command EA followed by
1579 * control data bytes. The command EA contains a command/response bit
1580 * and we divide up the work accordingly.
1581 */
1582
1583static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1584{
1585 /* See what command is involved */
1586 unsigned int command = 0;
1587 while (len-- > 0) {
1588 if (gsm_read_ea(&command, *data++) == 1) {
1589 int clen = *data++;
1590 len--;
1591 /* FIXME: this is properly an EA */
1592 clen >>= 1;
1593 /* Malformed command ? */
1594 if (clen > len)
1595 return;
1596 if (command & 1)
1597 gsm_control_message(dlci->gsm, command,
1598 data, clen);
1599 else
1600 gsm_control_response(dlci->gsm, command,
1601 data, clen);
1602 return;
1603 }
1604 }
1605}
1606
1607/*
1608 * Allocate/Free DLCI channels
1609 */
1610
1611/**
1612 * gsm_dlci_alloc - allocate a DLCI
1613 * @gsm: GSM mux
1614 * @addr: address of the DLCI
1615 *
1616 * Allocate and install a new DLCI object into the GSM mux.
1617 *
1618 * FIXME: review locking races
1619 */
1620
1621static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1622{
1623 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1624 if (dlci == NULL)
1625 return NULL;
1626 spin_lock_init(&dlci->lock);
Russ Gorby6ab8fba2011-06-16 14:20:13 -07001627 kref_init(&dlci->ref);
Russ Gorbybcd5abe2011-06-16 14:20:12 -07001628 mutex_init(&dlci->mutex);
Alan Coxe1eaea42010-03-26 11:32:54 +00001629 dlci->fifo = &dlci->_fifo;
1630 if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1631 kfree(dlci);
1632 return NULL;
1633 }
1634
1635 skb_queue_head_init(&dlci->skb_list);
1636 init_timer(&dlci->t1);
1637 dlci->t1.function = gsm_dlci_t1;
1638 dlci->t1.data = (unsigned long)dlci;
1639 tty_port_init(&dlci->port);
1640 dlci->port.ops = &gsm_port_ops;
1641 dlci->gsm = gsm;
1642 dlci->addr = addr;
1643 dlci->adaption = gsm->adaption;
1644 dlci->state = DLCI_CLOSED;
1645 if (addr)
1646 dlci->data = gsm_dlci_data;
1647 else
1648 dlci->data = gsm_dlci_command;
1649 gsm->dlci[addr] = dlci;
1650 return dlci;
1651}
1652
1653/**
Russ Gorby6ab8fba2011-06-16 14:20:13 -07001654 * gsm_dlci_free - free DLCI
1655 * @dlci: DLCI to free
Alan Coxe1eaea42010-03-26 11:32:54 +00001656 *
Russ Gorby6ab8fba2011-06-16 14:20:13 -07001657 * Free up a DLCI.
Alan Coxe1eaea42010-03-26 11:32:54 +00001658 *
1659 * Can sleep.
1660 */
Russ Gorby6ab8fba2011-06-16 14:20:13 -07001661static void gsm_dlci_free(struct kref *ref)
1662{
1663 struct gsm_dlci *dlci = container_of(ref, struct gsm_dlci, ref);
1664
1665 del_timer_sync(&dlci->t1);
1666 dlci->gsm->dlci[dlci->addr] = NULL;
1667 kfifo_free(dlci->fifo);
1668 while ((dlci->skb = skb_dequeue(&dlci->skb_list)))
1669 kfree_skb(dlci->skb);
1670 kfree(dlci);
1671}
1672
1673static inline void dlci_get(struct gsm_dlci *dlci)
1674{
1675 kref_get(&dlci->ref);
1676}
1677
1678static inline void dlci_put(struct gsm_dlci *dlci)
1679{
1680 kref_put(&dlci->ref, gsm_dlci_free);
1681}
1682
1683/**
1684 * gsm_dlci_release - release DLCI
1685 * @dlci: DLCI to destroy
1686 *
1687 * Release a DLCI. Actual free is deferred until either
1688 * mux is closed or tty is closed - whichever is last.
1689 *
1690 * Can sleep.
1691 */
1692static void gsm_dlci_release(struct gsm_dlci *dlci)
Alan Coxe1eaea42010-03-26 11:32:54 +00001693{
1694 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1695 if (tty) {
1696 tty_vhangup(tty);
1697 tty_kref_put(tty);
1698 }
Russ Gorby6ab8fba2011-06-16 14:20:13 -07001699 dlci_put(dlci);
Alan Coxe1eaea42010-03-26 11:32:54 +00001700}
1701
Alan Coxe1eaea42010-03-26 11:32:54 +00001702/*
1703 * LAPBish link layer logic
1704 */
1705
1706/**
1707 * gsm_queue - a GSM frame is ready to process
1708 * @gsm: pointer to our gsm mux
1709 *
1710 * At this point in time a frame has arrived and been demangled from
1711 * the line encoding. All the differences between the encodings have
1712 * been handled below us and the frame is unpacked into the structures.
1713 * The fcs holds the header FCS but any data FCS must be added here.
1714 */
1715
1716static void gsm_queue(struct gsm_mux *gsm)
1717{
1718 struct gsm_dlci *dlci;
1719 u8 cr;
1720 int address;
1721 /* We have to sneak a look at the packet body to do the FCS.
1722 A somewhat layering violation in the spec */
1723
1724 if ((gsm->control & ~PF) == UI)
1725 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
Mikhail Kshevetskiy9db4e432011-03-27 04:05:00 +04001726 if (gsm->encoding == 0){
1727 /* WARNING: gsm->received_fcs is used for gsm->encoding = 0 only.
1728 In this case it contain the last piece of data
1729 required to generate final CRC */
1730 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1731 }
Alan Coxe1eaea42010-03-26 11:32:54 +00001732 if (gsm->fcs != GOOD_FCS) {
1733 gsm->bad_fcs++;
1734 if (debug & 4)
Alan Cox5f9a31d2010-11-04 15:17:27 +00001735 pr_debug("BAD FCS %02x\n", gsm->fcs);
Alan Coxe1eaea42010-03-26 11:32:54 +00001736 return;
1737 }
1738 address = gsm->address >> 1;
1739 if (address >= NUM_DLCI)
1740 goto invalid;
1741
1742 cr = gsm->address & 1; /* C/R bit */
1743
1744 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1745
1746 cr ^= 1 - gsm->initiator; /* Flip so 1 always means command */
1747 dlci = gsm->dlci[address];
1748
1749 switch (gsm->control) {
1750 case SABM|PF:
1751 if (cr == 0)
1752 goto invalid;
1753 if (dlci == NULL)
1754 dlci = gsm_dlci_alloc(gsm, address);
1755 if (dlci == NULL)
1756 return;
1757 if (dlci->dead)
1758 gsm_response(gsm, address, DM);
1759 else {
1760 gsm_response(gsm, address, UA);
1761 gsm_dlci_open(dlci);
1762 }
1763 break;
1764 case DISC|PF:
1765 if (cr == 0)
1766 goto invalid;
1767 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1768 gsm_response(gsm, address, DM);
1769 return;
1770 }
1771 /* Real close complete */
1772 gsm_response(gsm, address, UA);
1773 gsm_dlci_close(dlci);
1774 break;
1775 case UA:
1776 case UA|PF:
1777 if (cr == 0 || dlci == NULL)
1778 break;
1779 switch (dlci->state) {
1780 case DLCI_CLOSING:
1781 gsm_dlci_close(dlci);
1782 break;
1783 case DLCI_OPENING:
1784 gsm_dlci_open(dlci);
1785 break;
1786 }
1787 break;
1788 case DM: /* DM can be valid unsolicited */
1789 case DM|PF:
1790 if (cr)
1791 goto invalid;
1792 if (dlci == NULL)
1793 return;
1794 gsm_dlci_close(dlci);
1795 break;
1796 case UI:
1797 case UI|PF:
1798 case UIH:
1799 case UIH|PF:
1800#if 0
1801 if (cr)
1802 goto invalid;
1803#endif
1804 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1805 gsm_command(gsm, address, DM|PF);
1806 return;
1807 }
1808 dlci->data(dlci, gsm->buf, gsm->len);
1809 break;
1810 default:
1811 goto invalid;
1812 }
1813 return;
1814invalid:
1815 gsm->malformed++;
1816 return;
1817}
1818
1819
1820/**
1821 * gsm0_receive - perform processing for non-transparency
1822 * @gsm: gsm data for this ldisc instance
1823 * @c: character
1824 *
1825 * Receive bytes in gsm mode 0
1826 */
1827
1828static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1829{
Alan Coxc2f2f002010-11-04 15:17:03 +00001830 unsigned int len;
1831
Alan Coxe1eaea42010-03-26 11:32:54 +00001832 switch (gsm->state) {
1833 case GSM_SEARCH: /* SOF marker */
1834 if (c == GSM0_SOF) {
1835 gsm->state = GSM_ADDRESS;
1836 gsm->address = 0;
1837 gsm->len = 0;
1838 gsm->fcs = INIT_FCS;
1839 }
Alan Coxc2f2f002010-11-04 15:17:03 +00001840 break;
1841 case GSM_ADDRESS: /* Address EA */
Alan Coxe1eaea42010-03-26 11:32:54 +00001842 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1843 if (gsm_read_ea(&gsm->address, c))
1844 gsm->state = GSM_CONTROL;
1845 break;
1846 case GSM_CONTROL: /* Control Byte */
1847 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1848 gsm->control = c;
Alan Coxc2f2f002010-11-04 15:17:03 +00001849 gsm->state = GSM_LEN0;
Alan Coxe1eaea42010-03-26 11:32:54 +00001850 break;
Alan Coxc2f2f002010-11-04 15:17:03 +00001851 case GSM_LEN0: /* Length EA */
Alan Coxe1eaea42010-03-26 11:32:54 +00001852 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1853 if (gsm_read_ea(&gsm->len, c)) {
1854 if (gsm->len > gsm->mru) {
1855 gsm->bad_size++;
1856 gsm->state = GSM_SEARCH;
1857 break;
1858 }
1859 gsm->count = 0;
Alan Coxc2f2f002010-11-04 15:17:03 +00001860 if (!gsm->len)
1861 gsm->state = GSM_FCS;
1862 else
1863 gsm->state = GSM_DATA;
1864 break;
Alan Coxe1eaea42010-03-26 11:32:54 +00001865 }
Alan Coxc2f2f002010-11-04 15:17:03 +00001866 gsm->state = GSM_LEN1;
1867 break;
1868 case GSM_LEN1:
1869 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1870 len = c;
1871 gsm->len |= len << 7;
1872 if (gsm->len > gsm->mru) {
1873 gsm->bad_size++;
1874 gsm->state = GSM_SEARCH;
1875 break;
1876 }
1877 gsm->count = 0;
1878 if (!gsm->len)
1879 gsm->state = GSM_FCS;
1880 else
1881 gsm->state = GSM_DATA;
Alan Coxe1eaea42010-03-26 11:32:54 +00001882 break;
1883 case GSM_DATA: /* Data */
1884 gsm->buf[gsm->count++] = c;
1885 if (gsm->count == gsm->len)
1886 gsm->state = GSM_FCS;
1887 break;
1888 case GSM_FCS: /* FCS follows the packet */
Alan Coxc2f2f002010-11-04 15:17:03 +00001889 gsm->received_fcs = c;
Alan Coxe1eaea42010-03-26 11:32:54 +00001890 gsm_queue(gsm);
Alan Coxc2f2f002010-11-04 15:17:03 +00001891 gsm->state = GSM_SSOF;
1892 break;
1893 case GSM_SSOF:
1894 if (c == GSM0_SOF) {
1895 gsm->state = GSM_SEARCH;
1896 break;
1897 }
Alan Coxe1eaea42010-03-26 11:32:54 +00001898 break;
1899 }
1900}
1901
1902/**
Alan Coxc2f2f002010-11-04 15:17:03 +00001903 * gsm1_receive - perform processing for non-transparency
Alan Coxe1eaea42010-03-26 11:32:54 +00001904 * @gsm: gsm data for this ldisc instance
1905 * @c: character
1906 *
1907 * Receive bytes in mode 1 (Advanced option)
1908 */
1909
1910static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1911{
1912 if (c == GSM1_SOF) {
1913 /* EOF is only valid in frame if we have got to the data state
1914 and received at least one byte (the FCS) */
1915 if (gsm->state == GSM_DATA && gsm->count) {
1916 /* Extract the FCS */
1917 gsm->count--;
1918 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1919 gsm->len = gsm->count;
1920 gsm_queue(gsm);
1921 gsm->state = GSM_START;
1922 return;
1923 }
1924 /* Any partial frame was a runt so go back to start */
1925 if (gsm->state != GSM_START) {
1926 gsm->malformed++;
1927 gsm->state = GSM_START;
1928 }
1929 /* A SOF in GSM_START means we are still reading idling or
1930 framing bytes */
1931 return;
1932 }
1933
1934 if (c == GSM1_ESCAPE) {
1935 gsm->escape = 1;
1936 return;
1937 }
1938
1939 /* Only an unescaped SOF gets us out of GSM search */
1940 if (gsm->state == GSM_SEARCH)
1941 return;
1942
1943 if (gsm->escape) {
1944 c ^= GSM1_ESCAPE_BITS;
1945 gsm->escape = 0;
1946 }
1947 switch (gsm->state) {
1948 case GSM_START: /* First byte after SOF */
1949 gsm->address = 0;
1950 gsm->state = GSM_ADDRESS;
1951 gsm->fcs = INIT_FCS;
1952 /* Drop through */
1953 case GSM_ADDRESS: /* Address continuation */
1954 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1955 if (gsm_read_ea(&gsm->address, c))
1956 gsm->state = GSM_CONTROL;
1957 break;
1958 case GSM_CONTROL: /* Control Byte */
1959 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1960 gsm->control = c;
1961 gsm->count = 0;
1962 gsm->state = GSM_DATA;
1963 break;
1964 case GSM_DATA: /* Data */
Alan Cox5f9a31d2010-11-04 15:17:27 +00001965 if (gsm->count > gsm->mru) { /* Allow one for the FCS */
Alan Coxe1eaea42010-03-26 11:32:54 +00001966 gsm->state = GSM_OVERRUN;
1967 gsm->bad_size++;
1968 } else
1969 gsm->buf[gsm->count++] = c;
1970 break;
1971 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */
1972 break;
1973 }
1974}
1975
1976/**
1977 * gsm_error - handle tty error
1978 * @gsm: ldisc data
1979 * @data: byte received (may be invalid)
1980 * @flag: error received
1981 *
1982 * Handle an error in the receipt of data for a frame. Currently we just
1983 * go back to hunting for a SOF.
1984 *
1985 * FIXME: better diagnostics ?
1986 */
1987
1988static void gsm_error(struct gsm_mux *gsm,
1989 unsigned char data, unsigned char flag)
1990{
1991 gsm->state = GSM_SEARCH;
1992 gsm->io_error++;
1993}
1994
1995/**
1996 * gsm_cleanup_mux - generic GSM protocol cleanup
1997 * @gsm: our mux
1998 *
1999 * Clean up the bits of the mux which are the same for all framing
2000 * protocols. Remove the mux from the mux table, stop all the timers
2001 * and then shut down each device hanging up the channels as we go.
2002 */
2003
2004void gsm_cleanup_mux(struct gsm_mux *gsm)
2005{
2006 int i;
2007 struct gsm_dlci *dlci = gsm->dlci[0];
2008 struct gsm_msg *txq;
Alan Coxf17141f2011-08-26 11:28:11 +01002009 struct gsm_control *gc;
Alan Coxe1eaea42010-03-26 11:32:54 +00002010
2011 gsm->dead = 1;
2012
2013 spin_lock(&gsm_mux_lock);
2014 for (i = 0; i < MAX_MUX; i++) {
2015 if (gsm_mux[i] == gsm) {
2016 gsm_mux[i] = NULL;
2017 break;
2018 }
2019 }
2020 spin_unlock(&gsm_mux_lock);
2021 WARN_ON(i == MAX_MUX);
2022
Alan Coxf17141f2011-08-26 11:28:11 +01002023 /* In theory disconnecting DLCI 0 is sufficient but for some
2024 modems this is apparently not the case. */
2025 if (dlci) {
2026 gc = gsm_control_send(gsm, CMD_CLD, NULL, 0);
2027 if (gc)
2028 gsm_control_wait(gsm, gc);
2029 }
Alan Coxe1eaea42010-03-26 11:32:54 +00002030 del_timer_sync(&gsm->t2_timer);
2031 /* Now we are sure T2 has stopped */
2032 if (dlci) {
2033 dlci->dead = 1;
2034 gsm_dlci_begin_close(dlci);
2035 wait_event_interruptible(gsm->event,
2036 dlci->state == DLCI_CLOSED);
2037 }
2038 /* Free up any link layer users */
2039 for (i = 0; i < NUM_DLCI; i++)
2040 if (gsm->dlci[i])
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002041 gsm_dlci_release(gsm->dlci[i]);
Alan Coxe1eaea42010-03-26 11:32:54 +00002042 /* Now wipe the queues */
2043 for (txq = gsm->tx_head; txq != NULL; txq = gsm->tx_head) {
2044 gsm->tx_head = txq->next;
2045 kfree(txq);
2046 }
2047 gsm->tx_tail = NULL;
2048}
2049EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
2050
2051/**
2052 * gsm_activate_mux - generic GSM setup
2053 * @gsm: our mux
2054 *
2055 * Set up the bits of the mux which are the same for all framing
2056 * protocols. Add the mux to the mux table so it can be opened and
2057 * finally kick off connecting to DLCI 0 on the modem.
2058 */
2059
2060int gsm_activate_mux(struct gsm_mux *gsm)
2061{
2062 struct gsm_dlci *dlci;
2063 int i = 0;
2064
2065 init_timer(&gsm->t2_timer);
2066 gsm->t2_timer.function = gsm_control_retransmit;
2067 gsm->t2_timer.data = (unsigned long)gsm;
2068 init_waitqueue_head(&gsm->event);
2069 spin_lock_init(&gsm->control_lock);
2070 spin_lock_init(&gsm->tx_lock);
2071
2072 if (gsm->encoding == 0)
2073 gsm->receive = gsm0_receive;
2074 else
2075 gsm->receive = gsm1_receive;
2076 gsm->error = gsm_error;
2077
2078 spin_lock(&gsm_mux_lock);
2079 for (i = 0; i < MAX_MUX; i++) {
2080 if (gsm_mux[i] == NULL) {
Russ Gorbyd50f6dc2011-06-14 13:35:32 -07002081 gsm->num = i;
Alan Coxe1eaea42010-03-26 11:32:54 +00002082 gsm_mux[i] = gsm;
2083 break;
2084 }
2085 }
2086 spin_unlock(&gsm_mux_lock);
2087 if (i == MAX_MUX)
2088 return -EBUSY;
2089
2090 dlci = gsm_dlci_alloc(gsm, 0);
2091 if (dlci == NULL)
2092 return -ENOMEM;
2093 gsm->dead = 0; /* Tty opens are now permissible */
2094 return 0;
2095}
2096EXPORT_SYMBOL_GPL(gsm_activate_mux);
2097
2098/**
2099 * gsm_free_mux - free up a mux
2100 * @mux: mux to free
2101 *
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002102 * Dispose of allocated resources for a dead mux
Alan Coxe1eaea42010-03-26 11:32:54 +00002103 */
2104void gsm_free_mux(struct gsm_mux *gsm)
2105{
2106 kfree(gsm->txframe);
2107 kfree(gsm->buf);
2108 kfree(gsm);
2109}
2110EXPORT_SYMBOL_GPL(gsm_free_mux);
2111
2112/**
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002113 * gsm_free_muxr - free up a mux
2114 * @mux: mux to free
2115 *
2116 * Dispose of allocated resources for a dead mux
2117 */
2118static void gsm_free_muxr(struct kref *ref)
2119{
2120 struct gsm_mux *gsm = container_of(ref, struct gsm_mux, ref);
2121 gsm_free_mux(gsm);
2122}
2123
2124static inline void mux_get(struct gsm_mux *gsm)
2125{
2126 kref_get(&gsm->ref);
2127}
2128
2129static inline void mux_put(struct gsm_mux *gsm)
2130{
2131 kref_put(&gsm->ref, gsm_free_muxr);
2132}
2133
2134/**
Alan Coxe1eaea42010-03-26 11:32:54 +00002135 * gsm_alloc_mux - allocate a mux
2136 *
2137 * Creates a new mux ready for activation.
2138 */
2139
2140struct gsm_mux *gsm_alloc_mux(void)
2141{
2142 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2143 if (gsm == NULL)
2144 return NULL;
2145 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2146 if (gsm->buf == NULL) {
2147 kfree(gsm);
2148 return NULL;
2149 }
2150 gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2151 if (gsm->txframe == NULL) {
2152 kfree(gsm->buf);
2153 kfree(gsm);
2154 return NULL;
2155 }
2156 spin_lock_init(&gsm->lock);
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002157 kref_init(&gsm->ref);
Alan Coxe1eaea42010-03-26 11:32:54 +00002158
2159 gsm->t1 = T1;
2160 gsm->t2 = T2;
2161 gsm->n2 = N2;
2162 gsm->ftype = UIH;
Alan Coxe1eaea42010-03-26 11:32:54 +00002163 gsm->adaption = 1;
2164 gsm->encoding = 1;
2165 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
2166 gsm->mtu = 64;
2167 gsm->dead = 1; /* Avoid early tty opens */
2168
2169 return gsm;
2170}
2171EXPORT_SYMBOL_GPL(gsm_alloc_mux);
2172
Alan Coxe1eaea42010-03-26 11:32:54 +00002173/**
2174 * gsmld_output - write to link
2175 * @gsm: our mux
2176 * @data: bytes to output
2177 * @len: size
2178 *
2179 * Write a block of data from the GSM mux to the data channel. This
2180 * will eventually be serialized from above but at the moment isn't.
2181 */
2182
2183static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2184{
2185 if (tty_write_room(gsm->tty) < len) {
2186 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2187 return -ENOSPC;
2188 }
Joe Perches0a77c4f2011-04-25 16:46:49 -07002189 if (debug & 4)
2190 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET,
2191 data, len);
Alan Coxe1eaea42010-03-26 11:32:54 +00002192 gsm->tty->ops->write(gsm->tty, data, len);
2193 return len;
2194}
2195
2196/**
2197 * gsmld_attach_gsm - mode set up
2198 * @tty: our tty structure
2199 * @gsm: our mux
2200 *
2201 * Set up the MUX for basic mode and commence connecting to the
2202 * modem. Currently called from the line discipline set up but
2203 * will need moving to an ioctl path.
2204 */
2205
2206static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2207{
Russ Gorbyd50f6dc2011-06-14 13:35:32 -07002208 int ret, i;
2209 int base = gsm->num << 6; /* Base for this MUX */
Alan Coxe1eaea42010-03-26 11:32:54 +00002210
2211 gsm->tty = tty_kref_get(tty);
2212 gsm->output = gsmld_output;
2213 ret = gsm_activate_mux(gsm);
2214 if (ret != 0)
2215 tty_kref_put(gsm->tty);
Russ Gorbyd50f6dc2011-06-14 13:35:32 -07002216 else {
2217 /* Don't register device 0 - this is the control channel and not
2218 a usable tty interface */
2219 for (i = 1; i < NUM_DLCI; i++)
2220 tty_register_device(gsm_tty_driver, base + i, NULL);
2221 }
Alan Coxe1eaea42010-03-26 11:32:54 +00002222 return ret;
2223}
2224
2225
2226/**
2227 * gsmld_detach_gsm - stop doing 0710 mux
Justin P. Mattock70f23fd2011-05-10 10:16:21 +02002228 * @tty: tty attached to the mux
Alan Coxe1eaea42010-03-26 11:32:54 +00002229 * @gsm: mux
2230 *
2231 * Shutdown and then clean up the resources used by the line discipline
2232 */
2233
2234static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2235{
Russ Gorbyd50f6dc2011-06-14 13:35:32 -07002236 int i;
2237 int base = gsm->num << 6; /* Base for this MUX */
2238
Alan Coxe1eaea42010-03-26 11:32:54 +00002239 WARN_ON(tty != gsm->tty);
Russ Gorbyd50f6dc2011-06-14 13:35:32 -07002240 for (i = 1; i < NUM_DLCI; i++)
2241 tty_unregister_device(gsm_tty_driver, base + i);
Alan Coxe1eaea42010-03-26 11:32:54 +00002242 gsm_cleanup_mux(gsm);
2243 tty_kref_put(gsm->tty);
2244 gsm->tty = NULL;
2245}
2246
Linus Torvalds55db4c62011-06-04 06:33:24 +09002247static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2248 char *fp, int count)
Alan Coxe1eaea42010-03-26 11:32:54 +00002249{
2250 struct gsm_mux *gsm = tty->disc_data;
2251 const unsigned char *dp;
2252 char *f;
2253 int i;
2254 char buf[64];
2255 char flags;
2256
Joe Perches0a77c4f2011-04-25 16:46:49 -07002257 if (debug & 4)
2258 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET,
2259 cp, count);
Alan Coxe1eaea42010-03-26 11:32:54 +00002260
2261 for (i = count, dp = cp, f = fp; i; i--, dp++) {
2262 flags = *f++;
2263 switch (flags) {
2264 case TTY_NORMAL:
2265 gsm->receive(gsm, *dp);
2266 break;
2267 case TTY_OVERRUN:
2268 case TTY_BREAK:
2269 case TTY_PARITY:
2270 case TTY_FRAME:
2271 gsm->error(gsm, *dp, flags);
2272 break;
2273 default:
Alan Cox5f9a31d2010-11-04 15:17:27 +00002274 WARN_ONCE("%s: unknown flag %d\n",
Alan Coxe1eaea42010-03-26 11:32:54 +00002275 tty_name(tty, buf), flags);
2276 break;
2277 }
2278 }
2279 /* FASYNC if needed ? */
2280 /* If clogged call tty_throttle(tty); */
2281}
2282
2283/**
2284 * gsmld_chars_in_buffer - report available bytes
2285 * @tty: tty device
2286 *
2287 * Report the number of characters buffered to be delivered to user
2288 * at this instant in time.
2289 *
2290 * Locking: gsm lock
2291 */
2292
2293static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
2294{
2295 return 0;
2296}
2297
2298/**
2299 * gsmld_flush_buffer - clean input queue
2300 * @tty: terminal device
2301 *
2302 * Flush the input buffer. Called when the line discipline is
2303 * being closed, when the tty layer wants the buffer flushed (eg
2304 * at hangup).
2305 */
2306
2307static void gsmld_flush_buffer(struct tty_struct *tty)
2308{
2309}
2310
2311/**
2312 * gsmld_close - close the ldisc for this tty
2313 * @tty: device
2314 *
2315 * Called from the terminal layer when this line discipline is
2316 * being shut down, either because of a close or becsuse of a
2317 * discipline change. The function will not be called while other
2318 * ldisc methods are in progress.
2319 */
2320
2321static void gsmld_close(struct tty_struct *tty)
2322{
2323 struct gsm_mux *gsm = tty->disc_data;
2324
2325 gsmld_detach_gsm(tty, gsm);
2326
2327 gsmld_flush_buffer(tty);
2328 /* Do other clean up here */
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002329 mux_put(gsm);
Alan Coxe1eaea42010-03-26 11:32:54 +00002330}
2331
2332/**
2333 * gsmld_open - open an ldisc
2334 * @tty: terminal to open
2335 *
2336 * Called when this line discipline is being attached to the
2337 * terminal device. Can sleep. Called serialized so that no
2338 * other events will occur in parallel. No further open will occur
2339 * until a close.
2340 */
2341
2342static int gsmld_open(struct tty_struct *tty)
2343{
2344 struct gsm_mux *gsm;
2345
2346 if (tty->ops->write == NULL)
2347 return -EINVAL;
2348
2349 /* Attach our ldisc data */
2350 gsm = gsm_alloc_mux();
2351 if (gsm == NULL)
2352 return -ENOMEM;
2353
2354 tty->disc_data = gsm;
2355 tty->receive_room = 65536;
2356
2357 /* Attach the initial passive connection */
2358 gsm->encoding = 1;
2359 return gsmld_attach_gsm(tty, gsm);
2360}
2361
2362/**
2363 * gsmld_write_wakeup - asynchronous I/O notifier
2364 * @tty: tty device
2365 *
2366 * Required for the ptys, serial driver etc. since processes
2367 * that attach themselves to the master and rely on ASYNC
2368 * IO must be woken up
2369 */
2370
2371static void gsmld_write_wakeup(struct tty_struct *tty)
2372{
2373 struct gsm_mux *gsm = tty->disc_data;
Dan Carpenter328be392010-05-25 11:37:17 +02002374 unsigned long flags;
Alan Coxe1eaea42010-03-26 11:32:54 +00002375
2376 /* Queue poll */
2377 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2378 gsm_data_kick(gsm);
Dan Carpenter328be392010-05-25 11:37:17 +02002379 if (gsm->tx_bytes < TX_THRESH_LO) {
2380 spin_lock_irqsave(&gsm->tx_lock, flags);
Alan Coxe1eaea42010-03-26 11:32:54 +00002381 gsm_dlci_data_sweep(gsm);
Dan Carpenter328be392010-05-25 11:37:17 +02002382 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2383 }
Alan Coxe1eaea42010-03-26 11:32:54 +00002384}
2385
2386/**
2387 * gsmld_read - read function for tty
2388 * @tty: tty device
2389 * @file: file object
2390 * @buf: userspace buffer pointer
2391 * @nr: size of I/O
2392 *
2393 * Perform reads for the line discipline. We are guaranteed that the
2394 * line discipline will not be closed under us but we may get multiple
2395 * parallel readers and must handle this ourselves. We may also get
2396 * a hangup. Always called in user context, may sleep.
2397 *
2398 * This code must be sure never to sleep through a hangup.
2399 */
2400
2401static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2402 unsigned char __user *buf, size_t nr)
2403{
2404 return -EOPNOTSUPP;
2405}
2406
2407/**
2408 * gsmld_write - write function for tty
2409 * @tty: tty device
2410 * @file: file object
2411 * @buf: userspace buffer pointer
2412 * @nr: size of I/O
2413 *
2414 * Called when the owner of the device wants to send a frame
2415 * itself (or some other control data). The data is transferred
2416 * as-is and must be properly framed and checksummed as appropriate
2417 * by userspace. Frames are either sent whole or not at all as this
2418 * avoids pain user side.
2419 */
2420
2421static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2422 const unsigned char *buf, size_t nr)
2423{
2424 int space = tty_write_room(tty);
2425 if (space >= nr)
2426 return tty->ops->write(tty, buf, nr);
2427 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2428 return -ENOBUFS;
2429}
2430
2431/**
2432 * gsmld_poll - poll method for N_GSM0710
2433 * @tty: terminal device
2434 * @file: file accessing it
2435 * @wait: poll table
2436 *
2437 * Called when the line discipline is asked to poll() for data or
2438 * for special events. This code is not serialized with respect to
2439 * other events save open/close.
2440 *
2441 * This code must be sure never to sleep through a hangup.
2442 * Called without the kernel lock held - fine
2443 */
2444
2445static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2446 poll_table *wait)
2447{
2448 unsigned int mask = 0;
2449 struct gsm_mux *gsm = tty->disc_data;
2450
2451 poll_wait(file, &tty->read_wait, wait);
2452 poll_wait(file, &tty->write_wait, wait);
2453 if (tty_hung_up_p(file))
2454 mask |= POLLHUP;
2455 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2456 mask |= POLLOUT | POLLWRNORM;
2457 if (gsm->dead)
2458 mask |= POLLHUP;
2459 return mask;
2460}
2461
2462static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2463 struct gsm_config *c)
2464{
2465 int need_close = 0;
2466 int need_restart = 0;
2467
2468 /* Stuff we don't support yet - UI or I frame transport, windowing */
Alan Cox5f9a31d2010-11-04 15:17:27 +00002469 if ((c->adaption != 1 && c->adaption != 2) || c->k)
Alan Coxe1eaea42010-03-26 11:32:54 +00002470 return -EOPNOTSUPP;
2471 /* Check the MRU/MTU range looks sane */
2472 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2473 return -EINVAL;
2474 if (c->n2 < 3)
2475 return -EINVAL;
2476 if (c->encapsulation > 1) /* Basic, advanced, no I */
2477 return -EINVAL;
2478 if (c->initiator > 1)
2479 return -EINVAL;
2480 if (c->i == 0 || c->i > 2) /* UIH and UI only */
2481 return -EINVAL;
2482 /*
2483 * See what is needed for reconfiguration
2484 */
2485
2486 /* Timing fields */
2487 if (c->t1 != 0 && c->t1 != gsm->t1)
2488 need_restart = 1;
2489 if (c->t2 != 0 && c->t2 != gsm->t2)
2490 need_restart = 1;
2491 if (c->encapsulation != gsm->encoding)
2492 need_restart = 1;
2493 if (c->adaption != gsm->adaption)
2494 need_restart = 1;
2495 /* Requires care */
2496 if (c->initiator != gsm->initiator)
2497 need_close = 1;
2498 if (c->mru != gsm->mru)
2499 need_restart = 1;
2500 if (c->mtu != gsm->mtu)
2501 need_restart = 1;
2502
2503 /*
2504 * Close down what is needed, restart and initiate the new
2505 * configuration
2506 */
2507
2508 if (need_close || need_restart) {
2509 gsm_dlci_begin_close(gsm->dlci[0]);
2510 /* This will timeout if the link is down due to N2 expiring */
2511 wait_event_interruptible(gsm->event,
2512 gsm->dlci[0]->state == DLCI_CLOSED);
2513 if (signal_pending(current))
2514 return -EINTR;
2515 }
2516 if (need_restart)
2517 gsm_cleanup_mux(gsm);
2518
2519 gsm->initiator = c->initiator;
2520 gsm->mru = c->mru;
Ken Mills91f78f32011-01-25 14:17:45 +00002521 gsm->mtu = c->mtu;
Alan Coxe1eaea42010-03-26 11:32:54 +00002522 gsm->encoding = c->encapsulation;
2523 gsm->adaption = c->adaption;
Ken Mills820e62e2010-11-04 15:16:24 +00002524 gsm->n2 = c->n2;
Alan Coxe1eaea42010-03-26 11:32:54 +00002525
2526 if (c->i == 1)
2527 gsm->ftype = UIH;
2528 else if (c->i == 2)
2529 gsm->ftype = UI;
2530
2531 if (c->t1)
2532 gsm->t1 = c->t1;
2533 if (c->t2)
2534 gsm->t2 = c->t2;
2535
2536 /* FIXME: We need to separate activation/deactivation from adding
2537 and removing from the mux array */
2538 if (need_restart)
2539 gsm_activate_mux(gsm);
2540 if (gsm->initiator && need_close)
2541 gsm_dlci_begin_open(gsm->dlci[0]);
2542 return 0;
2543}
2544
2545static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2546 unsigned int cmd, unsigned long arg)
2547{
2548 struct gsm_config c;
2549 struct gsm_mux *gsm = tty->disc_data;
2550
2551 switch (cmd) {
2552 case GSMIOC_GETCONF:
2553 memset(&c, 0, sizeof(c));
2554 c.adaption = gsm->adaption;
2555 c.encapsulation = gsm->encoding;
2556 c.initiator = gsm->initiator;
2557 c.t1 = gsm->t1;
2558 c.t2 = gsm->t2;
2559 c.t3 = 0; /* Not supported */
2560 c.n2 = gsm->n2;
2561 if (gsm->ftype == UIH)
2562 c.i = 1;
2563 else
2564 c.i = 2;
Alan Cox5f9a31d2010-11-04 15:17:27 +00002565 pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
Alan Coxe1eaea42010-03-26 11:32:54 +00002566 c.mru = gsm->mru;
2567 c.mtu = gsm->mtu;
2568 c.k = 0;
2569 if (copy_to_user((void *)arg, &c, sizeof(c)))
2570 return -EFAULT;
2571 return 0;
2572 case GSMIOC_SETCONF:
2573 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2574 return -EFAULT;
2575 return gsmld_config(tty, gsm, &c);
2576 default:
2577 return n_tty_ioctl_helper(tty, file, cmd, arg);
2578 }
2579}
2580
Russ Gorbybcd5abe2011-06-16 14:20:12 -07002581/*
2582 * Network interface
2583 *
2584 */
2585
2586static int gsm_mux_net_open(struct net_device *net)
2587{
2588 pr_debug("%s called\n", __func__);
2589 netif_start_queue(net);
2590 return 0;
2591}
2592
2593static int gsm_mux_net_close(struct net_device *net)
2594{
2595 netif_stop_queue(net);
2596 return 0;
2597}
2598
2599static struct net_device_stats *gsm_mux_net_get_stats(struct net_device *net)
2600{
2601 return &((struct gsm_mux_net *)netdev_priv(net))->stats;
2602}
2603static void dlci_net_free(struct gsm_dlci *dlci)
2604{
2605 if (!dlci->net) {
2606 WARN_ON(1);
2607 return;
2608 }
2609 dlci->adaption = dlci->prev_adaption;
2610 dlci->data = dlci->prev_data;
2611 free_netdev(dlci->net);
2612 dlci->net = NULL;
2613}
2614static void net_free(struct kref *ref)
2615{
2616 struct gsm_mux_net *mux_net;
2617 struct gsm_dlci *dlci;
2618
2619 mux_net = container_of(ref, struct gsm_mux_net, ref);
2620 dlci = mux_net->dlci;
2621
2622 if (dlci->net) {
2623 unregister_netdev(dlci->net);
2624 dlci_net_free(dlci);
2625 }
2626}
2627
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002628static inline void muxnet_get(struct gsm_mux_net *mux_net)
2629{
2630 kref_get(&mux_net->ref);
2631}
2632
2633static inline void muxnet_put(struct gsm_mux_net *mux_net)
2634{
2635 kref_put(&mux_net->ref, net_free);
2636}
2637
Russ Gorbybcd5abe2011-06-16 14:20:12 -07002638static int gsm_mux_net_start_xmit(struct sk_buff *skb,
2639 struct net_device *net)
2640{
2641 struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
2642 struct gsm_dlci *dlci = mux_net->dlci;
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002643 muxnet_get(mux_net);
Russ Gorbybcd5abe2011-06-16 14:20:12 -07002644
2645 skb_queue_head(&dlci->skb_list, skb);
2646 STATS(net).tx_packets++;
2647 STATS(net).tx_bytes += skb->len;
2648 gsm_dlci_data_kick(dlci);
2649 /* And tell the kernel when the last transmit started. */
2650 net->trans_start = jiffies;
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002651 muxnet_put(mux_net);
Russ Gorbybcd5abe2011-06-16 14:20:12 -07002652 return NETDEV_TX_OK;
2653}
2654
2655/* called when a packet did not ack after watchdogtimeout */
2656static void gsm_mux_net_tx_timeout(struct net_device *net)
2657{
2658 /* Tell syslog we are hosed. */
2659 dev_dbg(&net->dev, "Tx timed out.\n");
2660
2661 /* Update statistics */
2662 STATS(net).tx_errors++;
2663}
2664
2665static void gsm_mux_rx_netchar(struct gsm_dlci *dlci,
2666 unsigned char *in_buf, int size)
2667{
2668 struct net_device *net = dlci->net;
2669 struct sk_buff *skb;
2670 struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002671 muxnet_get(mux_net);
Russ Gorbybcd5abe2011-06-16 14:20:12 -07002672
2673 /* Allocate an sk_buff */
2674 skb = dev_alloc_skb(size + NET_IP_ALIGN);
2675 if (!skb) {
2676 /* We got no receive buffer. */
2677 STATS(net).rx_dropped++;
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002678 muxnet_put(mux_net);
Russ Gorbybcd5abe2011-06-16 14:20:12 -07002679 return;
2680 }
2681 skb_reserve(skb, NET_IP_ALIGN);
2682 memcpy(skb_put(skb, size), in_buf, size);
2683
2684 skb->dev = net;
2685 skb->protocol = __constant_htons(ETH_P_IP);
2686
2687 /* Ship it off to the kernel */
2688 netif_rx(skb);
2689
2690 /* update out statistics */
2691 STATS(net).rx_packets++;
2692 STATS(net).rx_bytes += size;
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002693 muxnet_put(mux_net);
Russ Gorbybcd5abe2011-06-16 14:20:12 -07002694 return;
2695}
2696
2697int gsm_change_mtu(struct net_device *net, int new_mtu)
2698{
2699 struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
2700 if ((new_mtu < 8) || (new_mtu > mux_net->dlci->gsm->mtu))
2701 return -EINVAL;
2702 net->mtu = new_mtu;
2703 return 0;
2704}
2705
2706static void gsm_mux_net_init(struct net_device *net)
2707{
2708 static const struct net_device_ops gsm_netdev_ops = {
2709 .ndo_open = gsm_mux_net_open,
2710 .ndo_stop = gsm_mux_net_close,
2711 .ndo_start_xmit = gsm_mux_net_start_xmit,
2712 .ndo_tx_timeout = gsm_mux_net_tx_timeout,
2713 .ndo_get_stats = gsm_mux_net_get_stats,
2714 .ndo_change_mtu = gsm_change_mtu,
2715 };
2716
2717 net->netdev_ops = &gsm_netdev_ops;
2718
2719 /* fill in the other fields */
2720 net->watchdog_timeo = GSM_NET_TX_TIMEOUT;
2721 net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
2722 net->type = ARPHRD_NONE;
2723 net->tx_queue_len = 10;
2724}
2725
2726
2727/* caller holds the dlci mutex */
2728static void gsm_destroy_network(struct gsm_dlci *dlci)
2729{
2730 struct gsm_mux_net *mux_net;
2731
2732 pr_debug("destroy network interface");
2733 if (!dlci->net)
2734 return;
2735 mux_net = (struct gsm_mux_net *)netdev_priv(dlci->net);
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002736 muxnet_put(mux_net);
Russ Gorbybcd5abe2011-06-16 14:20:12 -07002737}
2738
2739
2740/* caller holds the dlci mutex */
2741static int gsm_create_network(struct gsm_dlci *dlci, struct gsm_netconfig *nc)
2742{
2743 char *netname;
2744 int retval = 0;
2745 struct net_device *net;
2746 struct gsm_mux_net *mux_net;
2747
2748 if (!capable(CAP_NET_ADMIN))
2749 return -EPERM;
2750
2751 /* Already in a non tty mode */
2752 if (dlci->adaption > 2)
2753 return -EBUSY;
2754
2755 if (nc->protocol != htons(ETH_P_IP))
2756 return -EPROTONOSUPPORT;
2757
2758 if (nc->adaption != 3 && nc->adaption != 4)
2759 return -EPROTONOSUPPORT;
2760
2761 pr_debug("create network interface");
2762
2763 netname = "gsm%d";
2764 if (nc->if_name[0] != '\0')
2765 netname = nc->if_name;
2766 net = alloc_netdev(sizeof(struct gsm_mux_net),
2767 netname,
2768 gsm_mux_net_init);
2769 if (!net) {
2770 pr_err("alloc_netdev failed");
2771 return -ENOMEM;
2772 }
2773 net->mtu = dlci->gsm->mtu;
2774 mux_net = (struct gsm_mux_net *)netdev_priv(net);
2775 mux_net->dlci = dlci;
2776 kref_init(&mux_net->ref);
2777 strncpy(nc->if_name, net->name, IFNAMSIZ); /* return net name */
2778
2779 /* reconfigure dlci for network */
2780 dlci->prev_adaption = dlci->adaption;
2781 dlci->prev_data = dlci->data;
2782 dlci->adaption = nc->adaption;
2783 dlci->data = gsm_mux_rx_netchar;
2784 dlci->net = net;
2785
2786 pr_debug("register netdev");
2787 retval = register_netdev(net);
2788 if (retval) {
2789 pr_err("network register fail %d\n", retval);
2790 dlci_net_free(dlci);
2791 return retval;
2792 }
2793 return net->ifindex; /* return network index */
2794}
Alan Coxe1eaea42010-03-26 11:32:54 +00002795
2796/* Line discipline for real tty */
2797struct tty_ldisc_ops tty_ldisc_packet = {
2798 .owner = THIS_MODULE,
2799 .magic = TTY_LDISC_MAGIC,
2800 .name = "n_gsm",
2801 .open = gsmld_open,
2802 .close = gsmld_close,
2803 .flush_buffer = gsmld_flush_buffer,
2804 .chars_in_buffer = gsmld_chars_in_buffer,
2805 .read = gsmld_read,
2806 .write = gsmld_write,
2807 .ioctl = gsmld_ioctl,
2808 .poll = gsmld_poll,
2809 .receive_buf = gsmld_receive_buf,
2810 .write_wakeup = gsmld_write_wakeup
2811};
2812
2813/*
2814 * Virtual tty side
2815 */
2816
2817#define TX_SIZE 512
2818
2819static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2820{
2821 u8 modembits[5];
2822 struct gsm_control *ctrl;
2823 int len = 2;
2824
2825 if (brk)
2826 len++;
2827
2828 modembits[0] = len << 1 | EA; /* Data bytes */
2829 modembits[1] = dlci->addr << 2 | 3; /* DLCI, EA, 1 */
2830 modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2831 if (brk)
2832 modembits[3] = brk << 4 | 2 | EA; /* Valid, EA */
2833 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2834 if (ctrl == NULL)
2835 return -ENOMEM;
2836 return gsm_control_wait(dlci->gsm, ctrl);
2837}
2838
2839static int gsm_carrier_raised(struct tty_port *port)
2840{
2841 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2842 /* Not yet open so no carrier info */
2843 if (dlci->state != DLCI_OPEN)
2844 return 0;
2845 if (debug & 2)
2846 return 1;
2847 return dlci->modem_rx & TIOCM_CD;
2848}
2849
2850static void gsm_dtr_rts(struct tty_port *port, int onoff)
2851{
2852 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2853 unsigned int modem_tx = dlci->modem_tx;
2854 if (onoff)
2855 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2856 else
2857 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2858 if (modem_tx != dlci->modem_tx) {
2859 dlci->modem_tx = modem_tx;
2860 gsmtty_modem_update(dlci, 0);
2861 }
2862}
2863
2864static const struct tty_port_operations gsm_port_ops = {
2865 .carrier_raised = gsm_carrier_raised,
2866 .dtr_rts = gsm_dtr_rts,
2867};
2868
2869
2870static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2871{
2872 struct gsm_mux *gsm;
2873 struct gsm_dlci *dlci;
2874 struct tty_port *port;
2875 unsigned int line = tty->index;
2876 unsigned int mux = line >> 6;
2877
2878 line = line & 0x3F;
2879
2880 if (mux >= MAX_MUX)
2881 return -ENXIO;
2882 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2883 if (gsm_mux[mux] == NULL)
2884 return -EUNATCH;
2885 if (line == 0 || line > 61) /* 62/63 reserved */
2886 return -ECHRNG;
2887 gsm = gsm_mux[mux];
2888 if (gsm->dead)
2889 return -EL2HLT;
2890 dlci = gsm->dlci[line];
2891 if (dlci == NULL)
2892 dlci = gsm_dlci_alloc(gsm, line);
2893 if (dlci == NULL)
2894 return -ENOMEM;
2895 port = &dlci->port;
2896 port->count++;
2897 tty->driver_data = dlci;
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002898 dlci_get(dlci);
2899 dlci_get(dlci->gsm->dlci[0]);
2900 mux_get(dlci->gsm);
Alan Coxe1eaea42010-03-26 11:32:54 +00002901 tty_port_tty_set(port, tty);
2902
2903 dlci->modem_rx = 0;
2904 /* We could in theory open and close before we wait - eg if we get
2905 a DM straight back. This is ok as that will have caused a hangup */
2906 set_bit(ASYNCB_INITIALIZED, &port->flags);
2907 /* Start sending off SABM messages */
2908 gsm_dlci_begin_open(dlci);
2909 /* And wait for virtual carrier */
2910 return tty_port_block_til_ready(port, tty, filp);
2911}
2912
2913static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2914{
2915 struct gsm_dlci *dlci = tty->driver_data;
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002916 struct gsm_mux *gsm;
2917
Alan Coxe1eaea42010-03-26 11:32:54 +00002918 if (dlci == NULL)
2919 return;
Russ Gorbybcd5abe2011-06-16 14:20:12 -07002920 mutex_lock(&dlci->mutex);
2921 gsm_destroy_network(dlci);
2922 mutex_unlock(&dlci->mutex);
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002923 gsm = dlci->gsm;
Alan Coxe1eaea42010-03-26 11:32:54 +00002924 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002925 goto out;
Alan Coxe1eaea42010-03-26 11:32:54 +00002926 gsm_dlci_begin_close(dlci);
2927 tty_port_close_end(&dlci->port, tty);
2928 tty_port_tty_set(&dlci->port, NULL);
Russ Gorby6ab8fba2011-06-16 14:20:13 -07002929out:
2930 dlci_put(dlci);
2931 dlci_put(gsm->dlci[0]);
2932 mux_put(gsm);
Alan Coxe1eaea42010-03-26 11:32:54 +00002933}
2934
2935static void gsmtty_hangup(struct tty_struct *tty)
2936{
2937 struct gsm_dlci *dlci = tty->driver_data;
2938 tty_port_hangup(&dlci->port);
2939 gsm_dlci_begin_close(dlci);
2940}
2941
2942static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2943 int len)
2944{
2945 struct gsm_dlci *dlci = tty->driver_data;
2946 /* Stuff the bytes into the fifo queue */
2947 int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
2948 /* Need to kick the channel */
2949 gsm_dlci_data_kick(dlci);
2950 return sent;
2951}
2952
2953static int gsmtty_write_room(struct tty_struct *tty)
2954{
2955 struct gsm_dlci *dlci = tty->driver_data;
2956 return TX_SIZE - kfifo_len(dlci->fifo);
2957}
2958
2959static int gsmtty_chars_in_buffer(struct tty_struct *tty)
2960{
2961 struct gsm_dlci *dlci = tty->driver_data;
2962 return kfifo_len(dlci->fifo);
2963}
2964
2965static void gsmtty_flush_buffer(struct tty_struct *tty)
2966{
2967 struct gsm_dlci *dlci = tty->driver_data;
2968 /* Caution needed: If we implement reliable transport classes
2969 then the data being transmitted can't simply be junked once
2970 it has first hit the stack. Until then we can just blow it
2971 away */
2972 kfifo_reset(dlci->fifo);
2973 /* Need to unhook this DLCI from the transmit queue logic */
2974}
2975
2976static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
2977{
2978 /* The FIFO handles the queue so the kernel will do the right
2979 thing waiting on chars_in_buffer before calling us. No work
2980 to do here */
2981}
2982
Alan Cox60b33c12011-02-14 16:26:14 +00002983static int gsmtty_tiocmget(struct tty_struct *tty)
Alan Coxe1eaea42010-03-26 11:32:54 +00002984{
2985 struct gsm_dlci *dlci = tty->driver_data;
2986 return dlci->modem_rx;
2987}
2988
Alan Cox20b9d172011-02-14 16:26:50 +00002989static int gsmtty_tiocmset(struct tty_struct *tty,
Alan Coxe1eaea42010-03-26 11:32:54 +00002990 unsigned int set, unsigned int clear)
2991{
2992 struct gsm_dlci *dlci = tty->driver_data;
2993 unsigned int modem_tx = dlci->modem_tx;
2994
Nikola Diklic-Perincf168072011-09-23 10:59:43 +02002995 modem_tx &= ~clear;
Alan Coxe1eaea42010-03-26 11:32:54 +00002996 modem_tx |= set;
2997
2998 if (modem_tx != dlci->modem_tx) {
2999 dlci->modem_tx = modem_tx;
3000 return gsmtty_modem_update(dlci, 0);
3001 }
3002 return 0;
3003}
3004
3005
Alan Cox6caa76b2011-02-14 16:27:22 +00003006static int gsmtty_ioctl(struct tty_struct *tty,
Alan Coxe1eaea42010-03-26 11:32:54 +00003007 unsigned int cmd, unsigned long arg)
3008{
Russ Gorbybcd5abe2011-06-16 14:20:12 -07003009 struct gsm_dlci *dlci = tty->driver_data;
3010 struct gsm_netconfig nc;
3011 int index;
3012
3013 switch (cmd) {
3014 case GSMIOC_ENABLE_NET:
3015 if (copy_from_user(&nc, (void __user *)arg, sizeof(nc)))
3016 return -EFAULT;
3017 nc.if_name[IFNAMSIZ-1] = '\0';
3018 /* return net interface index or error code */
3019 mutex_lock(&dlci->mutex);
3020 index = gsm_create_network(dlci, &nc);
3021 mutex_unlock(&dlci->mutex);
3022 if (copy_to_user((void __user *)arg, &nc, sizeof(nc)))
3023 return -EFAULT;
3024 return index;
3025 case GSMIOC_DISABLE_NET:
3026 if (!capable(CAP_NET_ADMIN))
3027 return -EPERM;
3028 mutex_lock(&dlci->mutex);
3029 gsm_destroy_network(dlci);
3030 mutex_unlock(&dlci->mutex);
3031 return 0;
3032 default:
3033 return -ENOIOCTLCMD;
3034 }
Alan Coxe1eaea42010-03-26 11:32:54 +00003035}
3036
3037static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
3038{
3039 /* For the moment its fixed. In actual fact the speed information
3040 for the virtual channel can be propogated in both directions by
3041 the RPN control message. This however rapidly gets nasty as we
3042 then have to remap modem signals each way according to whether
3043 our virtual cable is null modem etc .. */
3044 tty_termios_copy_hw(tty->termios, old);
3045}
3046
3047static void gsmtty_throttle(struct tty_struct *tty)
3048{
3049 struct gsm_dlci *dlci = tty->driver_data;
3050 if (tty->termios->c_cflag & CRTSCTS)
3051 dlci->modem_tx &= ~TIOCM_DTR;
3052 dlci->throttled = 1;
3053 /* Send an MSC with DTR cleared */
3054 gsmtty_modem_update(dlci, 0);
3055}
3056
3057static void gsmtty_unthrottle(struct tty_struct *tty)
3058{
3059 struct gsm_dlci *dlci = tty->driver_data;
3060 if (tty->termios->c_cflag & CRTSCTS)
3061 dlci->modem_tx |= TIOCM_DTR;
3062 dlci->throttled = 0;
3063 /* Send an MSC with DTR set */
3064 gsmtty_modem_update(dlci, 0);
3065}
3066
3067static int gsmtty_break_ctl(struct tty_struct *tty, int state)
3068{
3069 struct gsm_dlci *dlci = tty->driver_data;
3070 int encode = 0; /* Off */
3071
3072 if (state == -1) /* "On indefinitely" - we can't encode this
3073 properly */
3074 encode = 0x0F;
3075 else if (state > 0) {
3076 encode = state / 200; /* mS to encoding */
3077 if (encode > 0x0F)
3078 encode = 0x0F; /* Best effort */
3079 }
3080 return gsmtty_modem_update(dlci, encode);
3081}
3082
Alan Coxe1eaea42010-03-26 11:32:54 +00003083
3084/* Virtual ttys for the demux */
3085static const struct tty_operations gsmtty_ops = {
3086 .open = gsmtty_open,
3087 .close = gsmtty_close,
3088 .write = gsmtty_write,
3089 .write_room = gsmtty_write_room,
3090 .chars_in_buffer = gsmtty_chars_in_buffer,
3091 .flush_buffer = gsmtty_flush_buffer,
3092 .ioctl = gsmtty_ioctl,
3093 .throttle = gsmtty_throttle,
3094 .unthrottle = gsmtty_unthrottle,
3095 .set_termios = gsmtty_set_termios,
3096 .hangup = gsmtty_hangup,
3097 .wait_until_sent = gsmtty_wait_until_sent,
3098 .tiocmget = gsmtty_tiocmget,
3099 .tiocmset = gsmtty_tiocmset,
3100 .break_ctl = gsmtty_break_ctl,
3101};
3102
3103
3104
3105static int __init gsm_init(void)
3106{
3107 /* Fill in our line protocol discipline, and register it */
3108 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
3109 if (status != 0) {
Alan Cox5f9a31d2010-11-04 15:17:27 +00003110 pr_err("n_gsm: can't register line discipline (err = %d)\n",
3111 status);
Alan Coxe1eaea42010-03-26 11:32:54 +00003112 return status;
3113 }
3114
3115 gsm_tty_driver = alloc_tty_driver(256);
3116 if (!gsm_tty_driver) {
3117 tty_unregister_ldisc(N_GSM0710);
Alan Cox5f9a31d2010-11-04 15:17:27 +00003118 pr_err("gsm_init: tty allocation failed.\n");
Alan Coxe1eaea42010-03-26 11:32:54 +00003119 return -EINVAL;
3120 }
3121 gsm_tty_driver->owner = THIS_MODULE;
3122 gsm_tty_driver->driver_name = "gsmtty";
3123 gsm_tty_driver->name = "gsmtty";
3124 gsm_tty_driver->major = 0; /* Dynamic */
3125 gsm_tty_driver->minor_start = 0;
3126 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
3127 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
3128 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
Alan Cox5f9a31d2010-11-04 15:17:27 +00003129 | TTY_DRIVER_HARDWARE_BREAK;
Alan Coxe1eaea42010-03-26 11:32:54 +00003130 gsm_tty_driver->init_termios = tty_std_termios;
3131 /* Fixme */
3132 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
3133 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
3134
3135 spin_lock_init(&gsm_mux_lock);
3136
3137 if (tty_register_driver(gsm_tty_driver)) {
3138 put_tty_driver(gsm_tty_driver);
3139 tty_unregister_ldisc(N_GSM0710);
Alan Cox5f9a31d2010-11-04 15:17:27 +00003140 pr_err("gsm_init: tty registration failed.\n");
Alan Coxe1eaea42010-03-26 11:32:54 +00003141 return -EBUSY;
3142 }
Alan Cox5f9a31d2010-11-04 15:17:27 +00003143 pr_debug("gsm_init: loaded as %d,%d.\n",
3144 gsm_tty_driver->major, gsm_tty_driver->minor_start);
Alan Coxe1eaea42010-03-26 11:32:54 +00003145 return 0;
3146}
3147
3148static void __exit gsm_exit(void)
3149{
3150 int status = tty_unregister_ldisc(N_GSM0710);
3151 if (status != 0)
Alan Cox5f9a31d2010-11-04 15:17:27 +00003152 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
3153 status);
Alan Coxe1eaea42010-03-26 11:32:54 +00003154 tty_unregister_driver(gsm_tty_driver);
3155 put_tty_driver(gsm_tty_driver);
Alan Coxe1eaea42010-03-26 11:32:54 +00003156}
3157
3158module_init(gsm_init);
3159module_exit(gsm_exit);
3160
3161
3162MODULE_LICENSE("GPL");
3163MODULE_ALIAS_LDISC(N_GSM0710);