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