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