Merge branch 'idle-release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb...
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / tty / n_gsm.c
bloba4c42a75a3bfea0f0143e8dd70454fde5dddf524
1 /*
2 * n_gsm.c GSM 0710 tty multiplexor
3 * Copyright (c) 2009/10 Intel Corporation
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.
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.
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.
18 * * THIS IS A DEVELOPMENT SNAPSHOT IT IS NOT A FINAL RELEASE *
20 * TO DO:
21 * Mostly done: ioctls for setting modes/timing
22 * Partly done: hooks so you can pull off frames to non tty devs
23 * Restart DLCI 0 when it closes ?
24 * Test basic encoding
25 * Improve the tx engine
26 * Resolve tx side locking by adding a queue_head and routing
27 * all control traffic via it
28 * General tidy/document
29 * Review the locking/move to refcounts more (mux now moved to an
30 * alloc/free model ready)
31 * Use newest tty open/close port helpers and install hooks
32 * What to do about power functions ?
33 * Termios setting and negotiation
34 * Do we need a 'which mux are you' ioctl to correlate mux and tty sets
38 #include <linux/types.h>
39 #include <linux/major.h>
40 #include <linux/errno.h>
41 #include <linux/signal.h>
42 #include <linux/fcntl.h>
43 #include <linux/sched.h>
44 #include <linux/interrupt.h>
45 #include <linux/tty.h>
46 #include <linux/ctype.h>
47 #include <linux/mm.h>
48 #include <linux/string.h>
49 #include <linux/slab.h>
50 #include <linux/poll.h>
51 #include <linux/bitops.h>
52 #include <linux/file.h>
53 #include <linux/uaccess.h>
54 #include <linux/module.h>
55 #include <linux/timer.h>
56 #include <linux/tty_flip.h>
57 #include <linux/tty_driver.h>
58 #include <linux/serial.h>
59 #include <linux/kfifo.h>
60 #include <linux/skbuff.h>
61 #include <linux/gsmmux.h>
63 static int debug;
64 module_param(debug, int, 0600);
66 #define T1 (HZ/10)
67 #define T2 (HZ/3)
68 #define N2 3
70 /* Use long timers for testing at low speed with debug on */
71 #ifdef DEBUG_TIMING
72 #define T1 HZ
73 #define T2 (2 * HZ)
74 #endif
77 * Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte
78 * limits so this is plenty
80 #define MAX_MRU 512
81 #define MAX_MTU 512
84 * Each block of data we have queued to go out is in the form of
85 * a gsm_msg which holds everything we need in a link layer independent
86 * format
89 struct gsm_msg {
90 struct gsm_msg *next;
91 u8 addr; /* DLCI address + flags */
92 u8 ctrl; /* Control byte + flags */
93 unsigned int len; /* Length of data block (can be zero) */
94 unsigned char *data; /* Points into buffer but not at the start */
95 unsigned char buffer[0];
99 * Each active data link has a gsm_dlci structure associated which ties
100 * the link layer to an optional tty (if the tty side is open). To avoid
101 * complexity right now these are only ever freed up when the mux is
102 * shut down.
104 * At the moment we don't free DLCI objects until the mux is torn down
105 * this avoid object life time issues but might be worth review later.
108 struct gsm_dlci {
109 struct gsm_mux *gsm;
110 int addr;
111 int state;
112 #define DLCI_CLOSED 0
113 #define DLCI_OPENING 1 /* Sending SABM not seen UA */
114 #define DLCI_OPEN 2 /* SABM/UA complete */
115 #define DLCI_CLOSING 3 /* Sending DISC not seen UA/DM */
117 /* Link layer */
118 spinlock_t lock; /* Protects the internal state */
119 struct timer_list t1; /* Retransmit timer for SABM and UA */
120 int retries;
121 /* Uplink tty if active */
122 struct tty_port port; /* The tty bound to this DLCI if there is one */
123 struct kfifo *fifo; /* Queue fifo for the DLCI */
124 struct kfifo _fifo; /* For new fifo API porting only */
125 int adaption; /* Adaption layer in use */
126 u32 modem_rx; /* Our incoming virtual modem lines */
127 u32 modem_tx; /* Our outgoing modem lines */
128 int dead; /* Refuse re-open */
129 /* Flow control */
130 int throttled; /* Private copy of throttle state */
131 int constipated; /* Throttle status for outgoing */
132 /* Packetised I/O */
133 struct sk_buff *skb; /* Frame being sent */
134 struct sk_buff_head skb_list; /* Queued frames */
135 /* Data handling callback */
136 void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
139 /* DLCI 0, 62/63 are special or reseved see gsmtty_open */
141 #define NUM_DLCI 64
144 * DLCI 0 is used to pass control blocks out of band of the data
145 * flow (and with a higher link priority). One command can be outstanding
146 * at a time and we use this structure to manage them. They are created
147 * and destroyed by the user context, and updated by the receive paths
148 * and timers
151 struct gsm_control {
152 u8 cmd; /* Command we are issuing */
153 u8 *data; /* Data for the command in case we retransmit */
154 int len; /* Length of block for retransmission */
155 int done; /* Done flag */
156 int error; /* Error if any */
160 * Each GSM mux we have is represented by this structure. If we are
161 * operating as an ldisc then we use this structure as our ldisc
162 * state. We need to sort out lifetimes and locking with respect
163 * to the gsm mux array. For now we don't free DLCI objects that
164 * have been instantiated until the mux itself is terminated.
166 * To consider further: tty open versus mux shutdown.
169 struct gsm_mux {
170 struct tty_struct *tty; /* The tty our ldisc is bound to */
171 spinlock_t lock;
173 /* Events on the GSM channel */
174 wait_queue_head_t event;
176 /* Bits for GSM mode decoding */
178 /* Framing Layer */
179 unsigned char *buf;
180 int state;
181 #define GSM_SEARCH 0
182 #define GSM_START 1
183 #define GSM_ADDRESS 2
184 #define GSM_CONTROL 3
185 #define GSM_LEN 4
186 #define GSM_DATA 5
187 #define GSM_FCS 6
188 #define GSM_OVERRUN 7
189 #define GSM_LEN0 8
190 #define GSM_LEN1 9
191 #define GSM_SSOF 10
192 unsigned int len;
193 unsigned int address;
194 unsigned int count;
195 int escape;
196 int encoding;
197 u8 control;
198 u8 fcs;
199 u8 received_fcs;
200 u8 *txframe; /* TX framing buffer */
202 /* Methods for the receiver side */
203 void (*receive)(struct gsm_mux *gsm, u8 ch);
204 void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
205 /* And transmit side */
206 int (*output)(struct gsm_mux *mux, u8 *data, int len);
208 /* Link Layer */
209 unsigned int mru;
210 unsigned int mtu;
211 int initiator; /* Did we initiate connection */
212 int dead; /* Has the mux been shut down */
213 struct gsm_dlci *dlci[NUM_DLCI];
214 int constipated; /* Asked by remote to shut up */
216 spinlock_t tx_lock;
217 unsigned int tx_bytes; /* TX data outstanding */
218 #define TX_THRESH_HI 8192
219 #define TX_THRESH_LO 2048
220 struct gsm_msg *tx_head; /* Pending data packets */
221 struct gsm_msg *tx_tail;
223 /* Control messages */
224 struct timer_list t2_timer; /* Retransmit timer for commands */
225 int cretries; /* Command retry counter */
226 struct gsm_control *pending_cmd;/* Our current pending command */
227 spinlock_t control_lock; /* Protects the pending command */
229 /* Configuration */
230 int adaption; /* 1 or 2 supported */
231 u8 ftype; /* UI or UIH */
232 int t1, t2; /* Timers in 1/100th of a sec */
233 int n2; /* Retry count */
235 /* Statistics (not currently exposed) */
236 unsigned long bad_fcs;
237 unsigned long malformed;
238 unsigned long io_error;
239 unsigned long bad_size;
240 unsigned long unsupported;
245 * Mux objects - needed so that we can translate a tty index into the
246 * relevant mux and DLCI.
249 #define MAX_MUX 4 /* 256 minors */
250 static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */
251 static spinlock_t gsm_mux_lock;
254 * This section of the driver logic implements the GSM encodings
255 * both the basic and the 'advanced'. Reliable transport is not
256 * supported.
259 #define CR 0x02
260 #define EA 0x01
261 #define PF 0x10
263 /* I is special: the rest are ..*/
264 #define RR 0x01
265 #define UI 0x03
266 #define RNR 0x05
267 #define REJ 0x09
268 #define DM 0x0F
269 #define SABM 0x2F
270 #define DISC 0x43
271 #define UA 0x63
272 #define UIH 0xEF
274 /* Channel commands */
275 #define CMD_NSC 0x09
276 #define CMD_TEST 0x11
277 #define CMD_PSC 0x21
278 #define CMD_RLS 0x29
279 #define CMD_FCOFF 0x31
280 #define CMD_PN 0x41
281 #define CMD_RPN 0x49
282 #define CMD_FCON 0x51
283 #define CMD_CLD 0x61
284 #define CMD_SNC 0x69
285 #define CMD_MSC 0x71
287 /* Virtual modem bits */
288 #define MDM_FC 0x01
289 #define MDM_RTC 0x02
290 #define MDM_RTR 0x04
291 #define MDM_IC 0x20
292 #define MDM_DV 0x40
294 #define GSM0_SOF 0xF9
295 #define GSM1_SOF 0x7E
296 #define GSM1_ESCAPE 0x7D
297 #define GSM1_ESCAPE_BITS 0x20
298 #define XON 0x11
299 #define XOFF 0x13
301 static const struct tty_port_operations gsm_port_ops;
304 * CRC table for GSM 0710
307 static const u8 gsm_fcs8[256] = {
308 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
309 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
310 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
311 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
312 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
313 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
314 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
315 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
316 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
317 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
318 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
319 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
320 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
321 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
322 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
323 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
324 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
325 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
326 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
327 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
328 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
329 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
330 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
331 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
332 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
333 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
334 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
335 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
336 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
337 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
338 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
339 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
342 #define INIT_FCS 0xFF
343 #define GOOD_FCS 0xCF
346 * gsm_fcs_add - update FCS
347 * @fcs: Current FCS
348 * @c: Next data
350 * Update the FCS to include c. Uses the algorithm in the specification
351 * notes.
354 static inline u8 gsm_fcs_add(u8 fcs, u8 c)
356 return gsm_fcs8[fcs ^ c];
360 * gsm_fcs_add_block - update FCS for a block
361 * @fcs: Current FCS
362 * @c: buffer of data
363 * @len: length of buffer
365 * Update the FCS to include c. Uses the algorithm in the specification
366 * notes.
369 static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
371 while (len--)
372 fcs = gsm_fcs8[fcs ^ *c++];
373 return fcs;
377 * gsm_read_ea - read a byte into an EA
378 * @val: variable holding value
379 * c: byte going into the EA
381 * Processes one byte of an EA. Updates the passed variable
382 * and returns 1 if the EA is now completely read
385 static int gsm_read_ea(unsigned int *val, u8 c)
387 /* Add the next 7 bits into the value */
388 *val <<= 7;
389 *val |= c >> 1;
390 /* Was this the last byte of the EA 1 = yes*/
391 return c & EA;
395 * gsm_encode_modem - encode modem data bits
396 * @dlci: DLCI to encode from
398 * Returns the correct GSM encoded modem status bits (6 bit field) for
399 * the current status of the DLCI and attached tty object
402 static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
404 u8 modembits = 0;
405 /* FC is true flow control not modem bits */
406 if (dlci->throttled)
407 modembits |= MDM_FC;
408 if (dlci->modem_tx & TIOCM_DTR)
409 modembits |= MDM_RTC;
410 if (dlci->modem_tx & TIOCM_RTS)
411 modembits |= MDM_RTR;
412 if (dlci->modem_tx & TIOCM_RI)
413 modembits |= MDM_IC;
414 if (dlci->modem_tx & TIOCM_CD)
415 modembits |= MDM_DV;
416 return modembits;
420 * gsm_print_packet - display a frame for debug
421 * @hdr: header to print before decode
422 * @addr: address EA from the frame
423 * @cr: C/R bit from the frame
424 * @control: control including PF bit
425 * @data: following data bytes
426 * @dlen: length of data
428 * Displays a packet in human readable format for debugging purposes. The
429 * style is based on amateur radio LAP-B dump display.
432 static void gsm_print_packet(const char *hdr, int addr, int cr,
433 u8 control, const u8 *data, int dlen)
435 if (!(debug & 1))
436 return;
438 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
440 switch (control & ~PF) {
441 case SABM:
442 pr_cont("SABM");
443 break;
444 case UA:
445 pr_cont("UA");
446 break;
447 case DISC:
448 pr_cont("DISC");
449 break;
450 case DM:
451 pr_cont("DM");
452 break;
453 case UI:
454 pr_cont("UI");
455 break;
456 case UIH:
457 pr_cont("UIH");
458 break;
459 default:
460 if (!(control & 0x01)) {
461 pr_cont("I N(S)%d N(R)%d",
462 (control & 0x0E) >> 1, (control & 0xE) >> 5);
463 } else switch (control & 0x0F) {
464 case RR:
465 pr_cont("RR(%d)", (control & 0xE0) >> 5);
466 break;
467 case RNR:
468 pr_cont("RNR(%d)", (control & 0xE0) >> 5);
469 break;
470 case REJ:
471 pr_cont("REJ(%d)", (control & 0xE0) >> 5);
472 break;
473 default:
474 pr_cont("[%02X]", control);
478 if (control & PF)
479 pr_cont("(P)");
480 else
481 pr_cont("(F)");
483 if (dlen) {
484 int ct = 0;
485 while (dlen--) {
486 if (ct % 8 == 0) {
487 pr_cont("\n");
488 pr_debug(" ");
490 pr_cont("%02X ", *data++);
491 ct++;
494 pr_cont("\n");
499 * Link level transmission side
503 * gsm_stuff_packet - bytestuff a packet
504 * @ibuf: input
505 * @obuf: output
506 * @len: length of input
508 * Expand a buffer by bytestuffing it. The worst case size change
509 * is doubling and the caller is responsible for handing out
510 * suitable sized buffers.
513 static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
515 int olen = 0;
516 while (len--) {
517 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
518 || *input == XON || *input == XOFF) {
519 *output++ = GSM1_ESCAPE;
520 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
521 olen++;
522 } else
523 *output++ = *input++;
524 olen++;
526 return olen;
530 * gsm_send - send a control frame
531 * @gsm: our GSM mux
532 * @addr: address for control frame
533 * @cr: command/response bit
534 * @control: control byte including PF bit
536 * Format up and transmit a control frame. These do not go via the
537 * queueing logic as they should be transmitted ahead of data when
538 * they are needed.
540 * FIXME: Lock versus data TX path
543 static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
545 int len;
546 u8 cbuf[10];
547 u8 ibuf[3];
549 switch (gsm->encoding) {
550 case 0:
551 cbuf[0] = GSM0_SOF;
552 cbuf[1] = (addr << 2) | (cr << 1) | EA;
553 cbuf[2] = control;
554 cbuf[3] = EA; /* Length of data = 0 */
555 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
556 cbuf[5] = GSM0_SOF;
557 len = 6;
558 break;
559 case 1:
560 case 2:
561 /* Control frame + packing (but not frame stuffing) in mode 1 */
562 ibuf[0] = (addr << 2) | (cr << 1) | EA;
563 ibuf[1] = control;
564 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
565 /* Stuffing may double the size worst case */
566 len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
567 /* Now add the SOF markers */
568 cbuf[0] = GSM1_SOF;
569 cbuf[len + 1] = GSM1_SOF;
570 /* FIXME: we can omit the lead one in many cases */
571 len += 2;
572 break;
573 default:
574 WARN_ON(1);
575 return;
577 gsm->output(gsm, cbuf, len);
578 gsm_print_packet("-->", addr, cr, control, NULL, 0);
582 * gsm_response - send a control response
583 * @gsm: our GSM mux
584 * @addr: address for control frame
585 * @control: control byte including PF bit
587 * Format up and transmit a link level response frame.
590 static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
592 gsm_send(gsm, addr, 0, control);
596 * gsm_command - send a control command
597 * @gsm: our GSM mux
598 * @addr: address for control frame
599 * @control: control byte including PF bit
601 * Format up and transmit a link level command frame.
604 static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
606 gsm_send(gsm, addr, 1, control);
609 /* Data transmission */
611 #define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
614 * gsm_data_alloc - allocate data frame
615 * @gsm: GSM mux
616 * @addr: DLCI address
617 * @len: length excluding header and FCS
618 * @ctrl: control byte
620 * Allocate a new data buffer for sending frames with data. Space is left
621 * at the front for header bytes but that is treated as an implementation
622 * detail and not for the high level code to use
625 static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
626 u8 ctrl)
628 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
629 GFP_ATOMIC);
630 if (m == NULL)
631 return NULL;
632 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */
633 m->len = len;
634 m->addr = addr;
635 m->ctrl = ctrl;
636 m->next = NULL;
637 return m;
641 * gsm_data_kick - poke the queue
642 * @gsm: GSM Mux
644 * The tty device has called us to indicate that room has appeared in
645 * the transmit queue. Ram more data into the pipe if we have any
647 * FIXME: lock against link layer control transmissions
650 static void gsm_data_kick(struct gsm_mux *gsm)
652 struct gsm_msg *msg = gsm->tx_head;
653 int len;
654 int skip_sof = 0;
656 /* FIXME: We need to apply this solely to data messages */
657 if (gsm->constipated)
658 return;
660 while (gsm->tx_head != NULL) {
661 msg = gsm->tx_head;
662 if (gsm->encoding != 0) {
663 gsm->txframe[0] = GSM1_SOF;
664 len = gsm_stuff_frame(msg->data,
665 gsm->txframe + 1, msg->len);
666 gsm->txframe[len + 1] = GSM1_SOF;
667 len += 2;
668 } else {
669 gsm->txframe[0] = GSM0_SOF;
670 memcpy(gsm->txframe + 1 , msg->data, msg->len);
671 gsm->txframe[msg->len + 1] = GSM0_SOF;
672 len = msg->len + 2;
675 if (debug & 4)
676 print_hex_dump_bytes("gsm_data_kick: ",
677 DUMP_PREFIX_OFFSET,
678 gsm->txframe, len);
680 if (gsm->output(gsm, gsm->txframe + skip_sof,
681 len - skip_sof) < 0)
682 break;
683 /* FIXME: Can eliminate one SOF in many more cases */
684 gsm->tx_head = msg->next;
685 if (gsm->tx_head == NULL)
686 gsm->tx_tail = NULL;
687 gsm->tx_bytes -= msg->len;
688 kfree(msg);
689 /* For a burst of frames skip the extra SOF within the
690 burst */
691 skip_sof = 1;
696 * __gsm_data_queue - queue a UI or UIH frame
697 * @dlci: DLCI sending the data
698 * @msg: message queued
700 * Add data to the transmit queue and try and get stuff moving
701 * out of the mux tty if not already doing so. The Caller must hold
702 * the gsm tx lock.
705 static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
707 struct gsm_mux *gsm = dlci->gsm;
708 u8 *dp = msg->data;
709 u8 *fcs = dp + msg->len;
711 /* Fill in the header */
712 if (gsm->encoding == 0) {
713 if (msg->len < 128)
714 *--dp = (msg->len << 1) | EA;
715 else {
716 *--dp = (msg->len >> 7); /* bits 7 - 15 */
717 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */
721 *--dp = msg->ctrl;
722 if (gsm->initiator)
723 *--dp = (msg->addr << 2) | 2 | EA;
724 else
725 *--dp = (msg->addr << 2) | EA;
726 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
727 /* Ugly protocol layering violation */
728 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
729 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
730 *fcs = 0xFF - *fcs;
732 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
733 msg->data, msg->len);
735 /* Move the header back and adjust the length, also allow for the FCS
736 now tacked on the end */
737 msg->len += (msg->data - dp) + 1;
738 msg->data = dp;
740 /* Add to the actual output queue */
741 if (gsm->tx_tail)
742 gsm->tx_tail->next = msg;
743 else
744 gsm->tx_head = msg;
745 gsm->tx_tail = msg;
746 gsm->tx_bytes += msg->len;
747 gsm_data_kick(gsm);
751 * gsm_data_queue - queue a UI or UIH frame
752 * @dlci: DLCI sending the data
753 * @msg: message queued
755 * Add data to the transmit queue and try and get stuff moving
756 * out of the mux tty if not already doing so. Take the
757 * the gsm tx lock and dlci lock.
760 static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
762 unsigned long flags;
763 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
764 __gsm_data_queue(dlci, msg);
765 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
769 * gsm_dlci_data_output - try and push data out of a DLCI
770 * @gsm: mux
771 * @dlci: the DLCI to pull data from
773 * Pull data from a DLCI and send it into the transmit queue if there
774 * is data. Keep to the MRU of the mux. This path handles the usual tty
775 * interface which is a byte stream with optional modem data.
777 * Caller must hold the tx_lock of the mux.
780 static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
782 struct gsm_msg *msg;
783 u8 *dp;
784 int len, size;
785 int h = dlci->adaption - 1;
787 len = kfifo_len(dlci->fifo);
788 if (len == 0)
789 return 0;
791 /* MTU/MRU count only the data bits */
792 if (len > gsm->mtu)
793 len = gsm->mtu;
795 size = len + h;
797 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
798 /* FIXME: need a timer or something to kick this so it can't
799 get stuck with no work outstanding and no buffer free */
800 if (msg == NULL)
801 return -ENOMEM;
802 dp = msg->data;
803 switch (dlci->adaption) {
804 case 1: /* Unstructured */
805 break;
806 case 2: /* Unstructed with modem bits. Always one byte as we never
807 send inline break data */
808 *dp += gsm_encode_modem(dlci);
809 len--;
810 break;
812 WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
813 __gsm_data_queue(dlci, msg);
814 /* Bytes of data we used up */
815 return size;
819 * gsm_dlci_data_output_framed - try and push data out of a DLCI
820 * @gsm: mux
821 * @dlci: the DLCI to pull data from
823 * Pull data from a DLCI and send it into the transmit queue if there
824 * is data. Keep to the MRU of the mux. This path handles framed data
825 * queued as skbuffs to the DLCI.
827 * Caller must hold the tx_lock of the mux.
830 static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
831 struct gsm_dlci *dlci)
833 struct gsm_msg *msg;
834 u8 *dp;
835 int len, size;
836 int last = 0, first = 0;
837 int overhead = 0;
839 /* One byte per frame is used for B/F flags */
840 if (dlci->adaption == 4)
841 overhead = 1;
843 /* dlci->skb is locked by tx_lock */
844 if (dlci->skb == NULL) {
845 dlci->skb = skb_dequeue(&dlci->skb_list);
846 if (dlci->skb == NULL)
847 return 0;
848 first = 1;
850 len = dlci->skb->len + overhead;
852 /* MTU/MRU count only the data bits */
853 if (len > gsm->mtu) {
854 if (dlci->adaption == 3) {
855 /* Over long frame, bin it */
856 kfree_skb(dlci->skb);
857 dlci->skb = NULL;
858 return 0;
860 len = gsm->mtu;
861 } else
862 last = 1;
864 size = len + overhead;
865 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
867 /* FIXME: need a timer or something to kick this so it can't
868 get stuck with no work outstanding and no buffer free */
869 if (msg == NULL)
870 return -ENOMEM;
871 dp = msg->data;
873 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
874 /* Flag byte to carry the start/end info */
875 *dp++ = last << 7 | first << 6 | 1; /* EA */
876 len--;
878 memcpy(dp, skb_pull(dlci->skb, len), len);
879 __gsm_data_queue(dlci, msg);
880 if (last)
881 dlci->skb = NULL;
882 return size;
886 * gsm_dlci_data_sweep - look for data to send
887 * @gsm: the GSM mux
889 * Sweep the GSM mux channels in priority order looking for ones with
890 * data to send. We could do with optimising this scan a bit. We aim
891 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
892 * TX_THRESH_LO we get called again
894 * FIXME: We should round robin between groups and in theory you can
895 * renegotiate DLCI priorities with optional stuff. Needs optimising.
898 static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
900 int len;
901 /* Priority ordering: We should do priority with RR of the groups */
902 int i = 1;
904 while (i < NUM_DLCI) {
905 struct gsm_dlci *dlci;
907 if (gsm->tx_bytes > TX_THRESH_HI)
908 break;
909 dlci = gsm->dlci[i];
910 if (dlci == NULL || dlci->constipated) {
911 i++;
912 continue;
914 if (dlci->adaption < 3)
915 len = gsm_dlci_data_output(gsm, dlci);
916 else
917 len = gsm_dlci_data_output_framed(gsm, dlci);
918 if (len < 0)
919 break;
920 /* DLCI empty - try the next */
921 if (len == 0)
922 i++;
927 * gsm_dlci_data_kick - transmit if possible
928 * @dlci: DLCI to kick
930 * Transmit data from this DLCI if the queue is empty. We can't rely on
931 * a tty wakeup except when we filled the pipe so we need to fire off
932 * new data ourselves in other cases.
935 static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
937 unsigned long flags;
939 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
940 /* If we have nothing running then we need to fire up */
941 if (dlci->gsm->tx_bytes == 0)
942 gsm_dlci_data_output(dlci->gsm, dlci);
943 else if (dlci->gsm->tx_bytes < TX_THRESH_LO)
944 gsm_dlci_data_sweep(dlci->gsm);
945 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
949 * Control message processing
954 * gsm_control_reply - send a response frame to a control
955 * @gsm: gsm channel
956 * @cmd: the command to use
957 * @data: data to follow encoded info
958 * @dlen: length of data
960 * Encode up and queue a UI/UIH frame containing our response.
963 static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
964 int dlen)
966 struct gsm_msg *msg;
967 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
968 if (msg == NULL)
969 return;
970 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */
971 msg->data[1] = (dlen << 1) | EA;
972 memcpy(msg->data + 2, data, dlen);
973 gsm_data_queue(gsm->dlci[0], msg);
977 * gsm_process_modem - process received modem status
978 * @tty: virtual tty bound to the DLCI
979 * @dlci: DLCI to affect
980 * @modem: modem bits (full EA)
982 * Used when a modem control message or line state inline in adaption
983 * layer 2 is processed. Sort out the local modem state and throttles
986 static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
987 u32 modem)
989 int mlines = 0;
990 u8 brk = modem >> 6;
992 /* Flow control/ready to communicate */
993 if (modem & MDM_FC) {
994 /* Need to throttle our output on this device */
995 dlci->constipated = 1;
997 if (modem & MDM_RTC) {
998 mlines |= TIOCM_DSR | TIOCM_DTR;
999 dlci->constipated = 0;
1000 gsm_dlci_data_kick(dlci);
1002 /* Map modem bits */
1003 if (modem & MDM_RTR)
1004 mlines |= TIOCM_RTS | TIOCM_CTS;
1005 if (modem & MDM_IC)
1006 mlines |= TIOCM_RI;
1007 if (modem & MDM_DV)
1008 mlines |= TIOCM_CD;
1010 /* Carrier drop -> hangup */
1011 if (tty) {
1012 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1013 if (!(tty->termios->c_cflag & CLOCAL))
1014 tty_hangup(tty);
1015 if (brk & 0x01)
1016 tty_insert_flip_char(tty, 0, TTY_BREAK);
1018 dlci->modem_rx = mlines;
1022 * gsm_control_modem - modem status received
1023 * @gsm: GSM channel
1024 * @data: data following command
1025 * @clen: command length
1027 * We have received a modem status control message. This is used by
1028 * the GSM mux protocol to pass virtual modem line status and optionally
1029 * to indicate break signals. Unpack it, convert to Linux representation
1030 * and if need be stuff a break message down the tty.
1033 static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1035 unsigned int addr = 0;
1036 unsigned int modem = 0;
1037 struct gsm_dlci *dlci;
1038 int len = clen;
1039 u8 *dp = data;
1040 struct tty_struct *tty;
1042 while (gsm_read_ea(&addr, *dp++) == 0) {
1043 len--;
1044 if (len == 0)
1045 return;
1047 /* Must be at least one byte following the EA */
1048 len--;
1049 if (len <= 0)
1050 return;
1052 addr >>= 1;
1053 /* Closed port, or invalid ? */
1054 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1055 return;
1056 dlci = gsm->dlci[addr];
1058 while (gsm_read_ea(&modem, *dp++) == 0) {
1059 len--;
1060 if (len == 0)
1061 return;
1063 tty = tty_port_tty_get(&dlci->port);
1064 gsm_process_modem(tty, dlci, modem);
1065 if (tty) {
1066 tty_wakeup(tty);
1067 tty_kref_put(tty);
1069 gsm_control_reply(gsm, CMD_MSC, data, clen);
1073 * gsm_control_rls - remote line status
1074 * @gsm: GSM channel
1075 * @data: data bytes
1076 * @clen: data length
1078 * The modem sends us a two byte message on the control channel whenever
1079 * it wishes to send us an error state from the virtual link. Stuff
1080 * this into the uplink tty if present
1083 static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1085 struct tty_struct *tty;
1086 unsigned int addr = 0 ;
1087 u8 bits;
1088 int len = clen;
1089 u8 *dp = data;
1091 while (gsm_read_ea(&addr, *dp++) == 0) {
1092 len--;
1093 if (len == 0)
1094 return;
1096 /* Must be at least one byte following ea */
1097 len--;
1098 if (len <= 0)
1099 return;
1100 addr >>= 1;
1101 /* Closed port, or invalid ? */
1102 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1103 return;
1104 /* No error ? */
1105 bits = *dp;
1106 if ((bits & 1) == 0)
1107 return;
1108 /* See if we have an uplink tty */
1109 tty = tty_port_tty_get(&gsm->dlci[addr]->port);
1111 if (tty) {
1112 if (bits & 2)
1113 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1114 if (bits & 4)
1115 tty_insert_flip_char(tty, 0, TTY_PARITY);
1116 if (bits & 8)
1117 tty_insert_flip_char(tty, 0, TTY_FRAME);
1118 tty_flip_buffer_push(tty);
1119 tty_kref_put(tty);
1121 gsm_control_reply(gsm, CMD_RLS, data, clen);
1124 static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1127 * gsm_control_message - DLCI 0 control processing
1128 * @gsm: our GSM mux
1129 * @command: the command EA
1130 * @data: data beyond the command/length EAs
1131 * @clen: length
1133 * Input processor for control messages from the other end of the link.
1134 * Processes the incoming request and queues a response frame or an
1135 * NSC response if not supported
1138 static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1139 u8 *data, int clen)
1141 u8 buf[1];
1142 switch (command) {
1143 case CMD_CLD: {
1144 struct gsm_dlci *dlci = gsm->dlci[0];
1145 /* Modem wishes to close down */
1146 if (dlci) {
1147 dlci->dead = 1;
1148 gsm->dead = 1;
1149 gsm_dlci_begin_close(dlci);
1152 break;
1153 case CMD_TEST:
1154 /* Modem wishes to test, reply with the data */
1155 gsm_control_reply(gsm, CMD_TEST, data, clen);
1156 break;
1157 case CMD_FCON:
1158 /* Modem wants us to STFU */
1159 gsm->constipated = 1;
1160 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1161 break;
1162 case CMD_FCOFF:
1163 /* Modem can accept data again */
1164 gsm->constipated = 0;
1165 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1166 /* Kick the link in case it is idling */
1167 gsm_data_kick(gsm);
1168 break;
1169 case CMD_MSC:
1170 /* Out of band modem line change indicator for a DLCI */
1171 gsm_control_modem(gsm, data, clen);
1172 break;
1173 case CMD_RLS:
1174 /* Out of band error reception for a DLCI */
1175 gsm_control_rls(gsm, data, clen);
1176 break;
1177 case CMD_PSC:
1178 /* Modem wishes to enter power saving state */
1179 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1180 break;
1181 /* Optional unsupported commands */
1182 case CMD_PN: /* Parameter negotiation */
1183 case CMD_RPN: /* Remote port negotiation */
1184 case CMD_SNC: /* Service negotiation command */
1185 default:
1186 /* Reply to bad commands with an NSC */
1187 buf[0] = command;
1188 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1189 break;
1194 * gsm_control_response - process a response to our control
1195 * @gsm: our GSM mux
1196 * @command: the command (response) EA
1197 * @data: data beyond the command/length EA
1198 * @clen: length
1200 * Process a response to an outstanding command. We only allow a single
1201 * control message in flight so this is fairly easy. All the clean up
1202 * is done by the caller, we just update the fields, flag it as done
1203 * and return
1206 static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1207 u8 *data, int clen)
1209 struct gsm_control *ctrl;
1210 unsigned long flags;
1212 spin_lock_irqsave(&gsm->control_lock, flags);
1214 ctrl = gsm->pending_cmd;
1215 /* Does the reply match our command */
1216 command |= 1;
1217 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1218 /* Our command was replied to, kill the retry timer */
1219 del_timer(&gsm->t2_timer);
1220 gsm->pending_cmd = NULL;
1221 /* Rejected by the other end */
1222 if (command == CMD_NSC)
1223 ctrl->error = -EOPNOTSUPP;
1224 ctrl->done = 1;
1225 wake_up(&gsm->event);
1227 spin_unlock_irqrestore(&gsm->control_lock, flags);
1231 * gsm_control_transmit - send control packet
1232 * @gsm: gsm mux
1233 * @ctrl: frame to send
1235 * Send out a pending control command (called under control lock)
1238 static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1240 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype);
1241 if (msg == NULL)
1242 return;
1243 msg->data[0] = (ctrl->cmd << 1) | 2 | EA; /* command */
1244 memcpy(msg->data + 1, ctrl->data, ctrl->len);
1245 gsm_data_queue(gsm->dlci[0], msg);
1249 * gsm_control_retransmit - retransmit a control frame
1250 * @data: pointer to our gsm object
1252 * Called off the T2 timer expiry in order to retransmit control frames
1253 * that have been lost in the system somewhere. The control_lock protects
1254 * us from colliding with another sender or a receive completion event.
1255 * In that situation the timer may still occur in a small window but
1256 * gsm->pending_cmd will be NULL and we just let the timer expire.
1259 static void gsm_control_retransmit(unsigned long data)
1261 struct gsm_mux *gsm = (struct gsm_mux *)data;
1262 struct gsm_control *ctrl;
1263 unsigned long flags;
1264 spin_lock_irqsave(&gsm->control_lock, flags);
1265 ctrl = gsm->pending_cmd;
1266 if (ctrl) {
1267 gsm->cretries--;
1268 if (gsm->cretries == 0) {
1269 gsm->pending_cmd = NULL;
1270 ctrl->error = -ETIMEDOUT;
1271 ctrl->done = 1;
1272 spin_unlock_irqrestore(&gsm->control_lock, flags);
1273 wake_up(&gsm->event);
1274 return;
1276 gsm_control_transmit(gsm, ctrl);
1277 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1279 spin_unlock_irqrestore(&gsm->control_lock, flags);
1283 * gsm_control_send - send a control frame on DLCI 0
1284 * @gsm: the GSM channel
1285 * @command: command to send including CR bit
1286 * @data: bytes of data (must be kmalloced)
1287 * @len: length of the block to send
1289 * Queue and dispatch a control command. Only one command can be
1290 * active at a time. In theory more can be outstanding but the matching
1291 * gets really complicated so for now stick to one outstanding.
1294 static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1295 unsigned int command, u8 *data, int clen)
1297 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1298 GFP_KERNEL);
1299 unsigned long flags;
1300 if (ctrl == NULL)
1301 return NULL;
1302 retry:
1303 wait_event(gsm->event, gsm->pending_cmd == NULL);
1304 spin_lock_irqsave(&gsm->control_lock, flags);
1305 if (gsm->pending_cmd != NULL) {
1306 spin_unlock_irqrestore(&gsm->control_lock, flags);
1307 goto retry;
1309 ctrl->cmd = command;
1310 ctrl->data = data;
1311 ctrl->len = clen;
1312 gsm->pending_cmd = ctrl;
1313 gsm->cretries = gsm->n2;
1314 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1315 gsm_control_transmit(gsm, ctrl);
1316 spin_unlock_irqrestore(&gsm->control_lock, flags);
1317 return ctrl;
1321 * gsm_control_wait - wait for a control to finish
1322 * @gsm: GSM mux
1323 * @control: control we are waiting on
1325 * Waits for the control to complete or time out. Frees any used
1326 * resources and returns 0 for success, or an error if the remote
1327 * rejected or ignored the request.
1330 static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1332 int err;
1333 wait_event(gsm->event, control->done == 1);
1334 err = control->error;
1335 kfree(control);
1336 return err;
1341 * DLCI level handling: Needs krefs
1345 * State transitions and timers
1349 * gsm_dlci_close - a DLCI has closed
1350 * @dlci: DLCI that closed
1352 * Perform processing when moving a DLCI into closed state. If there
1353 * is an attached tty this is hung up
1356 static void gsm_dlci_close(struct gsm_dlci *dlci)
1358 del_timer(&dlci->t1);
1359 if (debug & 8)
1360 pr_debug("DLCI %d goes closed.\n", dlci->addr);
1361 dlci->state = DLCI_CLOSED;
1362 if (dlci->addr != 0) {
1363 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1364 if (tty) {
1365 tty_hangup(tty);
1366 tty_kref_put(tty);
1368 kfifo_reset(dlci->fifo);
1369 } else
1370 dlci->gsm->dead = 1;
1371 wake_up(&dlci->gsm->event);
1372 /* A DLCI 0 close is a MUX termination so we need to kick that
1373 back to userspace somehow */
1377 * gsm_dlci_open - a DLCI has opened
1378 * @dlci: DLCI that opened
1380 * Perform processing when moving a DLCI into open state.
1383 static void gsm_dlci_open(struct gsm_dlci *dlci)
1385 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1386 open -> open */
1387 del_timer(&dlci->t1);
1388 /* This will let a tty open continue */
1389 dlci->state = DLCI_OPEN;
1390 if (debug & 8)
1391 pr_debug("DLCI %d goes open.\n", dlci->addr);
1392 wake_up(&dlci->gsm->event);
1396 * gsm_dlci_t1 - T1 timer expiry
1397 * @dlci: DLCI that opened
1399 * The T1 timer handles retransmits of control frames (essentially of
1400 * SABM and DISC). We resend the command until the retry count runs out
1401 * in which case an opening port goes back to closed and a closing port
1402 * is simply put into closed state (any further frames from the other
1403 * end will get a DM response)
1406 static void gsm_dlci_t1(unsigned long data)
1408 struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1409 struct gsm_mux *gsm = dlci->gsm;
1411 switch (dlci->state) {
1412 case DLCI_OPENING:
1413 dlci->retries--;
1414 if (dlci->retries) {
1415 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1416 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1417 } else
1418 gsm_dlci_close(dlci);
1419 break;
1420 case DLCI_CLOSING:
1421 dlci->retries--;
1422 if (dlci->retries) {
1423 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1424 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1425 } else
1426 gsm_dlci_close(dlci);
1427 break;
1432 * gsm_dlci_begin_open - start channel open procedure
1433 * @dlci: DLCI to open
1435 * Commence opening a DLCI from the Linux side. We issue SABM messages
1436 * to the modem which should then reply with a UA, at which point we
1437 * will move into open state. Opening is done asynchronously with retry
1438 * running off timers and the responses.
1441 static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1443 struct gsm_mux *gsm = dlci->gsm;
1444 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1445 return;
1446 dlci->retries = gsm->n2;
1447 dlci->state = DLCI_OPENING;
1448 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1449 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1453 * gsm_dlci_begin_close - start channel open procedure
1454 * @dlci: DLCI to open
1456 * Commence closing a DLCI from the Linux side. We issue DISC messages
1457 * to the modem which should then reply with a UA, at which point we
1458 * will move into closed state. Closing is done asynchronously with retry
1459 * off timers. We may also receive a DM reply from the other end which
1460 * indicates the channel was already closed.
1463 static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1465 struct gsm_mux *gsm = dlci->gsm;
1466 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1467 return;
1468 dlci->retries = gsm->n2;
1469 dlci->state = DLCI_CLOSING;
1470 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1471 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1475 * gsm_dlci_data - data arrived
1476 * @dlci: channel
1477 * @data: block of bytes received
1478 * @len: length of received block
1480 * A UI or UIH frame has arrived which contains data for a channel
1481 * other than the control channel. If the relevant virtual tty is
1482 * open we shovel the bits down it, if not we drop them.
1485 static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int len)
1487 /* krefs .. */
1488 struct tty_port *port = &dlci->port;
1489 struct tty_struct *tty = tty_port_tty_get(port);
1490 unsigned int modem = 0;
1492 if (debug & 16)
1493 pr_debug("%d bytes for tty %p\n", len, tty);
1494 if (tty) {
1495 switch (dlci->adaption) {
1496 /* Unsupported types */
1497 /* Packetised interruptible data */
1498 case 4:
1499 break;
1500 /* Packetised uininterruptible voice/data */
1501 case 3:
1502 break;
1503 /* Asynchronous serial with line state in each frame */
1504 case 2:
1505 while (gsm_read_ea(&modem, *data++) == 0) {
1506 len--;
1507 if (len == 0)
1508 return;
1510 gsm_process_modem(tty, dlci, modem);
1511 /* Line state will go via DLCI 0 controls only */
1512 case 1:
1513 default:
1514 tty_insert_flip_string(tty, data, len);
1515 tty_flip_buffer_push(tty);
1517 tty_kref_put(tty);
1522 * gsm_dlci_control - data arrived on control channel
1523 * @dlci: channel
1524 * @data: block of bytes received
1525 * @len: length of received block
1527 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1528 * control channel. This should contain a command EA followed by
1529 * control data bytes. The command EA contains a command/response bit
1530 * and we divide up the work accordingly.
1533 static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1535 /* See what command is involved */
1536 unsigned int command = 0;
1537 while (len-- > 0) {
1538 if (gsm_read_ea(&command, *data++) == 1) {
1539 int clen = *data++;
1540 len--;
1541 /* FIXME: this is properly an EA */
1542 clen >>= 1;
1543 /* Malformed command ? */
1544 if (clen > len)
1545 return;
1546 if (command & 1)
1547 gsm_control_message(dlci->gsm, command,
1548 data, clen);
1549 else
1550 gsm_control_response(dlci->gsm, command,
1551 data, clen);
1552 return;
1558 * Allocate/Free DLCI channels
1562 * gsm_dlci_alloc - allocate a DLCI
1563 * @gsm: GSM mux
1564 * @addr: address of the DLCI
1566 * Allocate and install a new DLCI object into the GSM mux.
1568 * FIXME: review locking races
1571 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1573 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1574 if (dlci == NULL)
1575 return NULL;
1576 spin_lock_init(&dlci->lock);
1577 dlci->fifo = &dlci->_fifo;
1578 if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1579 kfree(dlci);
1580 return NULL;
1583 skb_queue_head_init(&dlci->skb_list);
1584 init_timer(&dlci->t1);
1585 dlci->t1.function = gsm_dlci_t1;
1586 dlci->t1.data = (unsigned long)dlci;
1587 tty_port_init(&dlci->port);
1588 dlci->port.ops = &gsm_port_ops;
1589 dlci->gsm = gsm;
1590 dlci->addr = addr;
1591 dlci->adaption = gsm->adaption;
1592 dlci->state = DLCI_CLOSED;
1593 if (addr)
1594 dlci->data = gsm_dlci_data;
1595 else
1596 dlci->data = gsm_dlci_command;
1597 gsm->dlci[addr] = dlci;
1598 return dlci;
1602 * gsm_dlci_free - release DLCI
1603 * @dlci: DLCI to destroy
1605 * Free up a DLCI. Currently to keep the lifetime rules sane we only
1606 * clean up DLCI objects when the MUX closes rather than as the port
1607 * is closed down on both the tty and mux levels.
1609 * Can sleep.
1611 static void gsm_dlci_free(struct gsm_dlci *dlci)
1613 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1614 if (tty) {
1615 tty_vhangup(tty);
1616 tty_kref_put(tty);
1618 del_timer_sync(&dlci->t1);
1619 dlci->gsm->dlci[dlci->addr] = NULL;
1620 kfifo_free(dlci->fifo);
1621 kfree(dlci);
1625 * LAPBish link layer logic
1629 * gsm_queue - a GSM frame is ready to process
1630 * @gsm: pointer to our gsm mux
1632 * At this point in time a frame has arrived and been demangled from
1633 * the line encoding. All the differences between the encodings have
1634 * been handled below us and the frame is unpacked into the structures.
1635 * The fcs holds the header FCS but any data FCS must be added here.
1638 static void gsm_queue(struct gsm_mux *gsm)
1640 struct gsm_dlci *dlci;
1641 u8 cr;
1642 int address;
1643 /* We have to sneak a look at the packet body to do the FCS.
1644 A somewhat layering violation in the spec */
1646 if ((gsm->control & ~PF) == UI)
1647 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1648 if (gsm->encoding == 0){
1649 /* WARNING: gsm->received_fcs is used for gsm->encoding = 0 only.
1650 In this case it contain the last piece of data
1651 required to generate final CRC */
1652 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1654 if (gsm->fcs != GOOD_FCS) {
1655 gsm->bad_fcs++;
1656 if (debug & 4)
1657 pr_debug("BAD FCS %02x\n", gsm->fcs);
1658 return;
1660 address = gsm->address >> 1;
1661 if (address >= NUM_DLCI)
1662 goto invalid;
1664 cr = gsm->address & 1; /* C/R bit */
1666 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1668 cr ^= 1 - gsm->initiator; /* Flip so 1 always means command */
1669 dlci = gsm->dlci[address];
1671 switch (gsm->control) {
1672 case SABM|PF:
1673 if (cr == 0)
1674 goto invalid;
1675 if (dlci == NULL)
1676 dlci = gsm_dlci_alloc(gsm, address);
1677 if (dlci == NULL)
1678 return;
1679 if (dlci->dead)
1680 gsm_response(gsm, address, DM);
1681 else {
1682 gsm_response(gsm, address, UA);
1683 gsm_dlci_open(dlci);
1685 break;
1686 case DISC|PF:
1687 if (cr == 0)
1688 goto invalid;
1689 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1690 gsm_response(gsm, address, DM);
1691 return;
1693 /* Real close complete */
1694 gsm_response(gsm, address, UA);
1695 gsm_dlci_close(dlci);
1696 break;
1697 case UA:
1698 case UA|PF:
1699 if (cr == 0 || dlci == NULL)
1700 break;
1701 switch (dlci->state) {
1702 case DLCI_CLOSING:
1703 gsm_dlci_close(dlci);
1704 break;
1705 case DLCI_OPENING:
1706 gsm_dlci_open(dlci);
1707 break;
1709 break;
1710 case DM: /* DM can be valid unsolicited */
1711 case DM|PF:
1712 if (cr)
1713 goto invalid;
1714 if (dlci == NULL)
1715 return;
1716 gsm_dlci_close(dlci);
1717 break;
1718 case UI:
1719 case UI|PF:
1720 case UIH:
1721 case UIH|PF:
1722 #if 0
1723 if (cr)
1724 goto invalid;
1725 #endif
1726 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1727 gsm_command(gsm, address, DM|PF);
1728 return;
1730 dlci->data(dlci, gsm->buf, gsm->len);
1731 break;
1732 default:
1733 goto invalid;
1735 return;
1736 invalid:
1737 gsm->malformed++;
1738 return;
1743 * gsm0_receive - perform processing for non-transparency
1744 * @gsm: gsm data for this ldisc instance
1745 * @c: character
1747 * Receive bytes in gsm mode 0
1750 static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1752 unsigned int len;
1754 switch (gsm->state) {
1755 case GSM_SEARCH: /* SOF marker */
1756 if (c == GSM0_SOF) {
1757 gsm->state = GSM_ADDRESS;
1758 gsm->address = 0;
1759 gsm->len = 0;
1760 gsm->fcs = INIT_FCS;
1762 break;
1763 case GSM_ADDRESS: /* Address EA */
1764 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1765 if (gsm_read_ea(&gsm->address, c))
1766 gsm->state = GSM_CONTROL;
1767 break;
1768 case GSM_CONTROL: /* Control Byte */
1769 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1770 gsm->control = c;
1771 gsm->state = GSM_LEN0;
1772 break;
1773 case GSM_LEN0: /* Length EA */
1774 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1775 if (gsm_read_ea(&gsm->len, c)) {
1776 if (gsm->len > gsm->mru) {
1777 gsm->bad_size++;
1778 gsm->state = GSM_SEARCH;
1779 break;
1781 gsm->count = 0;
1782 if (!gsm->len)
1783 gsm->state = GSM_FCS;
1784 else
1785 gsm->state = GSM_DATA;
1786 break;
1788 gsm->state = GSM_LEN1;
1789 break;
1790 case GSM_LEN1:
1791 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1792 len = c;
1793 gsm->len |= len << 7;
1794 if (gsm->len > gsm->mru) {
1795 gsm->bad_size++;
1796 gsm->state = GSM_SEARCH;
1797 break;
1799 gsm->count = 0;
1800 if (!gsm->len)
1801 gsm->state = GSM_FCS;
1802 else
1803 gsm->state = GSM_DATA;
1804 break;
1805 case GSM_DATA: /* Data */
1806 gsm->buf[gsm->count++] = c;
1807 if (gsm->count == gsm->len)
1808 gsm->state = GSM_FCS;
1809 break;
1810 case GSM_FCS: /* FCS follows the packet */
1811 gsm->received_fcs = c;
1812 if (c == GSM0_SOF) {
1813 gsm->state = GSM_SEARCH;
1814 break;
1816 gsm_queue(gsm);
1817 gsm->state = GSM_SSOF;
1818 break;
1819 case GSM_SSOF:
1820 if (c == GSM0_SOF) {
1821 gsm->state = GSM_SEARCH;
1822 break;
1824 break;
1829 * gsm1_receive - perform processing for non-transparency
1830 * @gsm: gsm data for this ldisc instance
1831 * @c: character
1833 * Receive bytes in mode 1 (Advanced option)
1836 static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1838 if (c == GSM1_SOF) {
1839 /* EOF is only valid in frame if we have got to the data state
1840 and received at least one byte (the FCS) */
1841 if (gsm->state == GSM_DATA && gsm->count) {
1842 /* Extract the FCS */
1843 gsm->count--;
1844 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1845 gsm->len = gsm->count;
1846 gsm_queue(gsm);
1847 gsm->state = GSM_START;
1848 return;
1850 /* Any partial frame was a runt so go back to start */
1851 if (gsm->state != GSM_START) {
1852 gsm->malformed++;
1853 gsm->state = GSM_START;
1855 /* A SOF in GSM_START means we are still reading idling or
1856 framing bytes */
1857 return;
1860 if (c == GSM1_ESCAPE) {
1861 gsm->escape = 1;
1862 return;
1865 /* Only an unescaped SOF gets us out of GSM search */
1866 if (gsm->state == GSM_SEARCH)
1867 return;
1869 if (gsm->escape) {
1870 c ^= GSM1_ESCAPE_BITS;
1871 gsm->escape = 0;
1873 switch (gsm->state) {
1874 case GSM_START: /* First byte after SOF */
1875 gsm->address = 0;
1876 gsm->state = GSM_ADDRESS;
1877 gsm->fcs = INIT_FCS;
1878 /* Drop through */
1879 case GSM_ADDRESS: /* Address continuation */
1880 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1881 if (gsm_read_ea(&gsm->address, c))
1882 gsm->state = GSM_CONTROL;
1883 break;
1884 case GSM_CONTROL: /* Control Byte */
1885 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1886 gsm->control = c;
1887 gsm->count = 0;
1888 gsm->state = GSM_DATA;
1889 break;
1890 case GSM_DATA: /* Data */
1891 if (gsm->count > gsm->mru) { /* Allow one for the FCS */
1892 gsm->state = GSM_OVERRUN;
1893 gsm->bad_size++;
1894 } else
1895 gsm->buf[gsm->count++] = c;
1896 break;
1897 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */
1898 break;
1903 * gsm_error - handle tty error
1904 * @gsm: ldisc data
1905 * @data: byte received (may be invalid)
1906 * @flag: error received
1908 * Handle an error in the receipt of data for a frame. Currently we just
1909 * go back to hunting for a SOF.
1911 * FIXME: better diagnostics ?
1914 static void gsm_error(struct gsm_mux *gsm,
1915 unsigned char data, unsigned char flag)
1917 gsm->state = GSM_SEARCH;
1918 gsm->io_error++;
1922 * gsm_cleanup_mux - generic GSM protocol cleanup
1923 * @gsm: our mux
1925 * Clean up the bits of the mux which are the same for all framing
1926 * protocols. Remove the mux from the mux table, stop all the timers
1927 * and then shut down each device hanging up the channels as we go.
1930 void gsm_cleanup_mux(struct gsm_mux *gsm)
1932 int i;
1933 struct gsm_dlci *dlci = gsm->dlci[0];
1934 struct gsm_msg *txq;
1936 gsm->dead = 1;
1938 spin_lock(&gsm_mux_lock);
1939 for (i = 0; i < MAX_MUX; i++) {
1940 if (gsm_mux[i] == gsm) {
1941 gsm_mux[i] = NULL;
1942 break;
1945 spin_unlock(&gsm_mux_lock);
1946 WARN_ON(i == MAX_MUX);
1948 del_timer_sync(&gsm->t2_timer);
1949 /* Now we are sure T2 has stopped */
1950 if (dlci) {
1951 dlci->dead = 1;
1952 gsm_dlci_begin_close(dlci);
1953 wait_event_interruptible(gsm->event,
1954 dlci->state == DLCI_CLOSED);
1956 /* Free up any link layer users */
1957 for (i = 0; i < NUM_DLCI; i++)
1958 if (gsm->dlci[i])
1959 gsm_dlci_free(gsm->dlci[i]);
1960 /* Now wipe the queues */
1961 for (txq = gsm->tx_head; txq != NULL; txq = gsm->tx_head) {
1962 gsm->tx_head = txq->next;
1963 kfree(txq);
1965 gsm->tx_tail = NULL;
1967 EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
1970 * gsm_activate_mux - generic GSM setup
1971 * @gsm: our mux
1973 * Set up the bits of the mux which are the same for all framing
1974 * protocols. Add the mux to the mux table so it can be opened and
1975 * finally kick off connecting to DLCI 0 on the modem.
1978 int gsm_activate_mux(struct gsm_mux *gsm)
1980 struct gsm_dlci *dlci;
1981 int i = 0;
1983 init_timer(&gsm->t2_timer);
1984 gsm->t2_timer.function = gsm_control_retransmit;
1985 gsm->t2_timer.data = (unsigned long)gsm;
1986 init_waitqueue_head(&gsm->event);
1987 spin_lock_init(&gsm->control_lock);
1988 spin_lock_init(&gsm->tx_lock);
1990 if (gsm->encoding == 0)
1991 gsm->receive = gsm0_receive;
1992 else
1993 gsm->receive = gsm1_receive;
1994 gsm->error = gsm_error;
1996 spin_lock(&gsm_mux_lock);
1997 for (i = 0; i < MAX_MUX; i++) {
1998 if (gsm_mux[i] == NULL) {
1999 gsm_mux[i] = gsm;
2000 break;
2003 spin_unlock(&gsm_mux_lock);
2004 if (i == MAX_MUX)
2005 return -EBUSY;
2007 dlci = gsm_dlci_alloc(gsm, 0);
2008 if (dlci == NULL)
2009 return -ENOMEM;
2010 gsm->dead = 0; /* Tty opens are now permissible */
2011 return 0;
2013 EXPORT_SYMBOL_GPL(gsm_activate_mux);
2016 * gsm_free_mux - free up a mux
2017 * @mux: mux to free
2019 * Dispose of allocated resources for a dead mux. No refcounting
2020 * at present so the mux must be truly dead.
2022 void gsm_free_mux(struct gsm_mux *gsm)
2024 kfree(gsm->txframe);
2025 kfree(gsm->buf);
2026 kfree(gsm);
2028 EXPORT_SYMBOL_GPL(gsm_free_mux);
2031 * gsm_alloc_mux - allocate a mux
2033 * Creates a new mux ready for activation.
2036 struct gsm_mux *gsm_alloc_mux(void)
2038 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2039 if (gsm == NULL)
2040 return NULL;
2041 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2042 if (gsm->buf == NULL) {
2043 kfree(gsm);
2044 return NULL;
2046 gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2047 if (gsm->txframe == NULL) {
2048 kfree(gsm->buf);
2049 kfree(gsm);
2050 return NULL;
2052 spin_lock_init(&gsm->lock);
2054 gsm->t1 = T1;
2055 gsm->t2 = T2;
2056 gsm->n2 = N2;
2057 gsm->ftype = UIH;
2058 gsm->initiator = 0;
2059 gsm->adaption = 1;
2060 gsm->encoding = 1;
2061 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
2062 gsm->mtu = 64;
2063 gsm->dead = 1; /* Avoid early tty opens */
2065 return gsm;
2067 EXPORT_SYMBOL_GPL(gsm_alloc_mux);
2070 * gsmld_output - write to link
2071 * @gsm: our mux
2072 * @data: bytes to output
2073 * @len: size
2075 * Write a block of data from the GSM mux to the data channel. This
2076 * will eventually be serialized from above but at the moment isn't.
2079 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2081 if (tty_write_room(gsm->tty) < len) {
2082 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2083 return -ENOSPC;
2085 if (debug & 4)
2086 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET,
2087 data, len);
2088 gsm->tty->ops->write(gsm->tty, data, len);
2089 return len;
2093 * gsmld_attach_gsm - mode set up
2094 * @tty: our tty structure
2095 * @gsm: our mux
2097 * Set up the MUX for basic mode and commence connecting to the
2098 * modem. Currently called from the line discipline set up but
2099 * will need moving to an ioctl path.
2102 static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2104 int ret;
2106 gsm->tty = tty_kref_get(tty);
2107 gsm->output = gsmld_output;
2108 ret = gsm_activate_mux(gsm);
2109 if (ret != 0)
2110 tty_kref_put(gsm->tty);
2111 return ret;
2116 * gsmld_detach_gsm - stop doing 0710 mux
2117 * @tty: tty attached to the mux
2118 * @gsm: mux
2120 * Shutdown and then clean up the resources used by the line discipline
2123 static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2125 WARN_ON(tty != gsm->tty);
2126 gsm_cleanup_mux(gsm);
2127 tty_kref_put(gsm->tty);
2128 gsm->tty = NULL;
2131 static unsigned int gsmld_receive_buf(struct tty_struct *tty,
2132 const unsigned char *cp, char *fp, int count)
2134 struct gsm_mux *gsm = tty->disc_data;
2135 const unsigned char *dp;
2136 char *f;
2137 int i;
2138 char buf[64];
2139 char flags;
2141 if (debug & 4)
2142 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET,
2143 cp, count);
2145 for (i = count, dp = cp, f = fp; i; i--, dp++) {
2146 flags = *f++;
2147 switch (flags) {
2148 case TTY_NORMAL:
2149 gsm->receive(gsm, *dp);
2150 break;
2151 case TTY_OVERRUN:
2152 case TTY_BREAK:
2153 case TTY_PARITY:
2154 case TTY_FRAME:
2155 gsm->error(gsm, *dp, flags);
2156 break;
2157 default:
2158 WARN_ONCE("%s: unknown flag %d\n",
2159 tty_name(tty, buf), flags);
2160 break;
2163 /* FASYNC if needed ? */
2164 /* If clogged call tty_throttle(tty); */
2166 return count;
2170 * gsmld_chars_in_buffer - report available bytes
2171 * @tty: tty device
2173 * Report the number of characters buffered to be delivered to user
2174 * at this instant in time.
2176 * Locking: gsm lock
2179 static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
2181 return 0;
2185 * gsmld_flush_buffer - clean input queue
2186 * @tty: terminal device
2188 * Flush the input buffer. Called when the line discipline is
2189 * being closed, when the tty layer wants the buffer flushed (eg
2190 * at hangup).
2193 static void gsmld_flush_buffer(struct tty_struct *tty)
2198 * gsmld_close - close the ldisc for this tty
2199 * @tty: device
2201 * Called from the terminal layer when this line discipline is
2202 * being shut down, either because of a close or becsuse of a
2203 * discipline change. The function will not be called while other
2204 * ldisc methods are in progress.
2207 static void gsmld_close(struct tty_struct *tty)
2209 struct gsm_mux *gsm = tty->disc_data;
2211 gsmld_detach_gsm(tty, gsm);
2213 gsmld_flush_buffer(tty);
2214 /* Do other clean up here */
2215 gsm_free_mux(gsm);
2219 * gsmld_open - open an ldisc
2220 * @tty: terminal to open
2222 * Called when this line discipline is being attached to the
2223 * terminal device. Can sleep. Called serialized so that no
2224 * other events will occur in parallel. No further open will occur
2225 * until a close.
2228 static int gsmld_open(struct tty_struct *tty)
2230 struct gsm_mux *gsm;
2232 if (tty->ops->write == NULL)
2233 return -EINVAL;
2235 /* Attach our ldisc data */
2236 gsm = gsm_alloc_mux();
2237 if (gsm == NULL)
2238 return -ENOMEM;
2240 tty->disc_data = gsm;
2241 tty->receive_room = 65536;
2243 /* Attach the initial passive connection */
2244 gsm->encoding = 1;
2245 return gsmld_attach_gsm(tty, gsm);
2249 * gsmld_write_wakeup - asynchronous I/O notifier
2250 * @tty: tty device
2252 * Required for the ptys, serial driver etc. since processes
2253 * that attach themselves to the master and rely on ASYNC
2254 * IO must be woken up
2257 static void gsmld_write_wakeup(struct tty_struct *tty)
2259 struct gsm_mux *gsm = tty->disc_data;
2260 unsigned long flags;
2262 /* Queue poll */
2263 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2264 gsm_data_kick(gsm);
2265 if (gsm->tx_bytes < TX_THRESH_LO) {
2266 spin_lock_irqsave(&gsm->tx_lock, flags);
2267 gsm_dlci_data_sweep(gsm);
2268 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2273 * gsmld_read - read function for tty
2274 * @tty: tty device
2275 * @file: file object
2276 * @buf: userspace buffer pointer
2277 * @nr: size of I/O
2279 * Perform reads for the line discipline. We are guaranteed that the
2280 * line discipline will not be closed under us but we may get multiple
2281 * parallel readers and must handle this ourselves. We may also get
2282 * a hangup. Always called in user context, may sleep.
2284 * This code must be sure never to sleep through a hangup.
2287 static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2288 unsigned char __user *buf, size_t nr)
2290 return -EOPNOTSUPP;
2294 * gsmld_write - write function for tty
2295 * @tty: tty device
2296 * @file: file object
2297 * @buf: userspace buffer pointer
2298 * @nr: size of I/O
2300 * Called when the owner of the device wants to send a frame
2301 * itself (or some other control data). The data is transferred
2302 * as-is and must be properly framed and checksummed as appropriate
2303 * by userspace. Frames are either sent whole or not at all as this
2304 * avoids pain user side.
2307 static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2308 const unsigned char *buf, size_t nr)
2310 int space = tty_write_room(tty);
2311 if (space >= nr)
2312 return tty->ops->write(tty, buf, nr);
2313 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2314 return -ENOBUFS;
2318 * gsmld_poll - poll method for N_GSM0710
2319 * @tty: terminal device
2320 * @file: file accessing it
2321 * @wait: poll table
2323 * Called when the line discipline is asked to poll() for data or
2324 * for special events. This code is not serialized with respect to
2325 * other events save open/close.
2327 * This code must be sure never to sleep through a hangup.
2328 * Called without the kernel lock held - fine
2331 static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2332 poll_table *wait)
2334 unsigned int mask = 0;
2335 struct gsm_mux *gsm = tty->disc_data;
2337 poll_wait(file, &tty->read_wait, wait);
2338 poll_wait(file, &tty->write_wait, wait);
2339 if (tty_hung_up_p(file))
2340 mask |= POLLHUP;
2341 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2342 mask |= POLLOUT | POLLWRNORM;
2343 if (gsm->dead)
2344 mask |= POLLHUP;
2345 return mask;
2348 static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2349 struct gsm_config *c)
2351 int need_close = 0;
2352 int need_restart = 0;
2354 /* Stuff we don't support yet - UI or I frame transport, windowing */
2355 if ((c->adaption != 1 && c->adaption != 2) || c->k)
2356 return -EOPNOTSUPP;
2357 /* Check the MRU/MTU range looks sane */
2358 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2359 return -EINVAL;
2360 if (c->n2 < 3)
2361 return -EINVAL;
2362 if (c->encapsulation > 1) /* Basic, advanced, no I */
2363 return -EINVAL;
2364 if (c->initiator > 1)
2365 return -EINVAL;
2366 if (c->i == 0 || c->i > 2) /* UIH and UI only */
2367 return -EINVAL;
2369 * See what is needed for reconfiguration
2372 /* Timing fields */
2373 if (c->t1 != 0 && c->t1 != gsm->t1)
2374 need_restart = 1;
2375 if (c->t2 != 0 && c->t2 != gsm->t2)
2376 need_restart = 1;
2377 if (c->encapsulation != gsm->encoding)
2378 need_restart = 1;
2379 if (c->adaption != gsm->adaption)
2380 need_restart = 1;
2381 /* Requires care */
2382 if (c->initiator != gsm->initiator)
2383 need_close = 1;
2384 if (c->mru != gsm->mru)
2385 need_restart = 1;
2386 if (c->mtu != gsm->mtu)
2387 need_restart = 1;
2390 * Close down what is needed, restart and initiate the new
2391 * configuration
2394 if (need_close || need_restart) {
2395 gsm_dlci_begin_close(gsm->dlci[0]);
2396 /* This will timeout if the link is down due to N2 expiring */
2397 wait_event_interruptible(gsm->event,
2398 gsm->dlci[0]->state == DLCI_CLOSED);
2399 if (signal_pending(current))
2400 return -EINTR;
2402 if (need_restart)
2403 gsm_cleanup_mux(gsm);
2405 gsm->initiator = c->initiator;
2406 gsm->mru = c->mru;
2407 gsm->mtu = c->mtu;
2408 gsm->encoding = c->encapsulation;
2409 gsm->adaption = c->adaption;
2410 gsm->n2 = c->n2;
2412 if (c->i == 1)
2413 gsm->ftype = UIH;
2414 else if (c->i == 2)
2415 gsm->ftype = UI;
2417 if (c->t1)
2418 gsm->t1 = c->t1;
2419 if (c->t2)
2420 gsm->t2 = c->t2;
2422 /* FIXME: We need to separate activation/deactivation from adding
2423 and removing from the mux array */
2424 if (need_restart)
2425 gsm_activate_mux(gsm);
2426 if (gsm->initiator && need_close)
2427 gsm_dlci_begin_open(gsm->dlci[0]);
2428 return 0;
2431 static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2432 unsigned int cmd, unsigned long arg)
2434 struct gsm_config c;
2435 struct gsm_mux *gsm = tty->disc_data;
2437 switch (cmd) {
2438 case GSMIOC_GETCONF:
2439 memset(&c, 0, sizeof(c));
2440 c.adaption = gsm->adaption;
2441 c.encapsulation = gsm->encoding;
2442 c.initiator = gsm->initiator;
2443 c.t1 = gsm->t1;
2444 c.t2 = gsm->t2;
2445 c.t3 = 0; /* Not supported */
2446 c.n2 = gsm->n2;
2447 if (gsm->ftype == UIH)
2448 c.i = 1;
2449 else
2450 c.i = 2;
2451 pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
2452 c.mru = gsm->mru;
2453 c.mtu = gsm->mtu;
2454 c.k = 0;
2455 if (copy_to_user((void *)arg, &c, sizeof(c)))
2456 return -EFAULT;
2457 return 0;
2458 case GSMIOC_SETCONF:
2459 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2460 return -EFAULT;
2461 return gsmld_config(tty, gsm, &c);
2462 default:
2463 return n_tty_ioctl_helper(tty, file, cmd, arg);
2468 /* Line discipline for real tty */
2469 struct tty_ldisc_ops tty_ldisc_packet = {
2470 .owner = THIS_MODULE,
2471 .magic = TTY_LDISC_MAGIC,
2472 .name = "n_gsm",
2473 .open = gsmld_open,
2474 .close = gsmld_close,
2475 .flush_buffer = gsmld_flush_buffer,
2476 .chars_in_buffer = gsmld_chars_in_buffer,
2477 .read = gsmld_read,
2478 .write = gsmld_write,
2479 .ioctl = gsmld_ioctl,
2480 .poll = gsmld_poll,
2481 .receive_buf = gsmld_receive_buf,
2482 .write_wakeup = gsmld_write_wakeup
2486 * Virtual tty side
2489 #define TX_SIZE 512
2491 static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2493 u8 modembits[5];
2494 struct gsm_control *ctrl;
2495 int len = 2;
2497 if (brk)
2498 len++;
2500 modembits[0] = len << 1 | EA; /* Data bytes */
2501 modembits[1] = dlci->addr << 2 | 3; /* DLCI, EA, 1 */
2502 modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2503 if (brk)
2504 modembits[3] = brk << 4 | 2 | EA; /* Valid, EA */
2505 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2506 if (ctrl == NULL)
2507 return -ENOMEM;
2508 return gsm_control_wait(dlci->gsm, ctrl);
2511 static int gsm_carrier_raised(struct tty_port *port)
2513 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2514 /* Not yet open so no carrier info */
2515 if (dlci->state != DLCI_OPEN)
2516 return 0;
2517 if (debug & 2)
2518 return 1;
2519 return dlci->modem_rx & TIOCM_CD;
2522 static void gsm_dtr_rts(struct tty_port *port, int onoff)
2524 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2525 unsigned int modem_tx = dlci->modem_tx;
2526 if (onoff)
2527 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2528 else
2529 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2530 if (modem_tx != dlci->modem_tx) {
2531 dlci->modem_tx = modem_tx;
2532 gsmtty_modem_update(dlci, 0);
2536 static const struct tty_port_operations gsm_port_ops = {
2537 .carrier_raised = gsm_carrier_raised,
2538 .dtr_rts = gsm_dtr_rts,
2542 static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2544 struct gsm_mux *gsm;
2545 struct gsm_dlci *dlci;
2546 struct tty_port *port;
2547 unsigned int line = tty->index;
2548 unsigned int mux = line >> 6;
2550 line = line & 0x3F;
2552 if (mux >= MAX_MUX)
2553 return -ENXIO;
2554 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2555 if (gsm_mux[mux] == NULL)
2556 return -EUNATCH;
2557 if (line == 0 || line > 61) /* 62/63 reserved */
2558 return -ECHRNG;
2559 gsm = gsm_mux[mux];
2560 if (gsm->dead)
2561 return -EL2HLT;
2562 dlci = gsm->dlci[line];
2563 if (dlci == NULL)
2564 dlci = gsm_dlci_alloc(gsm, line);
2565 if (dlci == NULL)
2566 return -ENOMEM;
2567 port = &dlci->port;
2568 port->count++;
2569 tty->driver_data = dlci;
2570 tty_port_tty_set(port, tty);
2572 dlci->modem_rx = 0;
2573 /* We could in theory open and close before we wait - eg if we get
2574 a DM straight back. This is ok as that will have caused a hangup */
2575 set_bit(ASYNCB_INITIALIZED, &port->flags);
2576 /* Start sending off SABM messages */
2577 gsm_dlci_begin_open(dlci);
2578 /* And wait for virtual carrier */
2579 return tty_port_block_til_ready(port, tty, filp);
2582 static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2584 struct gsm_dlci *dlci = tty->driver_data;
2585 if (dlci == NULL)
2586 return;
2587 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
2588 return;
2589 gsm_dlci_begin_close(dlci);
2590 tty_port_close_end(&dlci->port, tty);
2591 tty_port_tty_set(&dlci->port, NULL);
2594 static void gsmtty_hangup(struct tty_struct *tty)
2596 struct gsm_dlci *dlci = tty->driver_data;
2597 tty_port_hangup(&dlci->port);
2598 gsm_dlci_begin_close(dlci);
2601 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2602 int len)
2604 struct gsm_dlci *dlci = tty->driver_data;
2605 /* Stuff the bytes into the fifo queue */
2606 int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
2607 /* Need to kick the channel */
2608 gsm_dlci_data_kick(dlci);
2609 return sent;
2612 static int gsmtty_write_room(struct tty_struct *tty)
2614 struct gsm_dlci *dlci = tty->driver_data;
2615 return TX_SIZE - kfifo_len(dlci->fifo);
2618 static int gsmtty_chars_in_buffer(struct tty_struct *tty)
2620 struct gsm_dlci *dlci = tty->driver_data;
2621 return kfifo_len(dlci->fifo);
2624 static void gsmtty_flush_buffer(struct tty_struct *tty)
2626 struct gsm_dlci *dlci = tty->driver_data;
2627 /* Caution needed: If we implement reliable transport classes
2628 then the data being transmitted can't simply be junked once
2629 it has first hit the stack. Until then we can just blow it
2630 away */
2631 kfifo_reset(dlci->fifo);
2632 /* Need to unhook this DLCI from the transmit queue logic */
2635 static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
2637 /* The FIFO handles the queue so the kernel will do the right
2638 thing waiting on chars_in_buffer before calling us. No work
2639 to do here */
2642 static int gsmtty_tiocmget(struct tty_struct *tty)
2644 struct gsm_dlci *dlci = tty->driver_data;
2645 return dlci->modem_rx;
2648 static int gsmtty_tiocmset(struct tty_struct *tty,
2649 unsigned int set, unsigned int clear)
2651 struct gsm_dlci *dlci = tty->driver_data;
2652 unsigned int modem_tx = dlci->modem_tx;
2654 modem_tx &= clear;
2655 modem_tx |= set;
2657 if (modem_tx != dlci->modem_tx) {
2658 dlci->modem_tx = modem_tx;
2659 return gsmtty_modem_update(dlci, 0);
2661 return 0;
2665 static int gsmtty_ioctl(struct tty_struct *tty,
2666 unsigned int cmd, unsigned long arg)
2668 return -ENOIOCTLCMD;
2671 static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
2673 /* For the moment its fixed. In actual fact the speed information
2674 for the virtual channel can be propogated in both directions by
2675 the RPN control message. This however rapidly gets nasty as we
2676 then have to remap modem signals each way according to whether
2677 our virtual cable is null modem etc .. */
2678 tty_termios_copy_hw(tty->termios, old);
2681 static void gsmtty_throttle(struct tty_struct *tty)
2683 struct gsm_dlci *dlci = tty->driver_data;
2684 if (tty->termios->c_cflag & CRTSCTS)
2685 dlci->modem_tx &= ~TIOCM_DTR;
2686 dlci->throttled = 1;
2687 /* Send an MSC with DTR cleared */
2688 gsmtty_modem_update(dlci, 0);
2691 static void gsmtty_unthrottle(struct tty_struct *tty)
2693 struct gsm_dlci *dlci = tty->driver_data;
2694 if (tty->termios->c_cflag & CRTSCTS)
2695 dlci->modem_tx |= TIOCM_DTR;
2696 dlci->throttled = 0;
2697 /* Send an MSC with DTR set */
2698 gsmtty_modem_update(dlci, 0);
2701 static int gsmtty_break_ctl(struct tty_struct *tty, int state)
2703 struct gsm_dlci *dlci = tty->driver_data;
2704 int encode = 0; /* Off */
2706 if (state == -1) /* "On indefinitely" - we can't encode this
2707 properly */
2708 encode = 0x0F;
2709 else if (state > 0) {
2710 encode = state / 200; /* mS to encoding */
2711 if (encode > 0x0F)
2712 encode = 0x0F; /* Best effort */
2714 return gsmtty_modem_update(dlci, encode);
2717 static struct tty_driver *gsm_tty_driver;
2719 /* Virtual ttys for the demux */
2720 static const struct tty_operations gsmtty_ops = {
2721 .open = gsmtty_open,
2722 .close = gsmtty_close,
2723 .write = gsmtty_write,
2724 .write_room = gsmtty_write_room,
2725 .chars_in_buffer = gsmtty_chars_in_buffer,
2726 .flush_buffer = gsmtty_flush_buffer,
2727 .ioctl = gsmtty_ioctl,
2728 .throttle = gsmtty_throttle,
2729 .unthrottle = gsmtty_unthrottle,
2730 .set_termios = gsmtty_set_termios,
2731 .hangup = gsmtty_hangup,
2732 .wait_until_sent = gsmtty_wait_until_sent,
2733 .tiocmget = gsmtty_tiocmget,
2734 .tiocmset = gsmtty_tiocmset,
2735 .break_ctl = gsmtty_break_ctl,
2740 static int __init gsm_init(void)
2742 /* Fill in our line protocol discipline, and register it */
2743 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
2744 if (status != 0) {
2745 pr_err("n_gsm: can't register line discipline (err = %d)\n",
2746 status);
2747 return status;
2750 gsm_tty_driver = alloc_tty_driver(256);
2751 if (!gsm_tty_driver) {
2752 tty_unregister_ldisc(N_GSM0710);
2753 pr_err("gsm_init: tty allocation failed.\n");
2754 return -EINVAL;
2756 gsm_tty_driver->owner = THIS_MODULE;
2757 gsm_tty_driver->driver_name = "gsmtty";
2758 gsm_tty_driver->name = "gsmtty";
2759 gsm_tty_driver->major = 0; /* Dynamic */
2760 gsm_tty_driver->minor_start = 0;
2761 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
2762 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
2763 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
2764 | TTY_DRIVER_HARDWARE_BREAK;
2765 gsm_tty_driver->init_termios = tty_std_termios;
2766 /* Fixme */
2767 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
2768 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
2770 spin_lock_init(&gsm_mux_lock);
2772 if (tty_register_driver(gsm_tty_driver)) {
2773 put_tty_driver(gsm_tty_driver);
2774 tty_unregister_ldisc(N_GSM0710);
2775 pr_err("gsm_init: tty registration failed.\n");
2776 return -EBUSY;
2778 pr_debug("gsm_init: loaded as %d,%d.\n",
2779 gsm_tty_driver->major, gsm_tty_driver->minor_start);
2780 return 0;
2783 static void __exit gsm_exit(void)
2785 int status = tty_unregister_ldisc(N_GSM0710);
2786 if (status != 0)
2787 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
2788 status);
2789 tty_unregister_driver(gsm_tty_driver);
2790 put_tty_driver(gsm_tty_driver);
2793 module_init(gsm_init);
2794 module_exit(gsm_exit);
2797 MODULE_LICENSE("GPL");
2798 MODULE_ALIAS_LDISC(N_GSM0710);