1 // SPDX-License-Identifier: GPL-2.0
3 * n_gsm.c GSM 0710 tty multiplexor
4 * Copyright (c) 2009/10 Intel Corporation
6 * * THIS IS A DEVELOPMENT SNAPSHOT IT IS NOT A FINAL RELEASE *
9 * Mostly done: ioctls for setting modes/timing
10 * Partly done: hooks so you can pull off frames to non tty devs
11 * Restart DLCI 0 when it closes ?
12 * Improve the tx engine
13 * Resolve tx side locking by adding a queue_head and routing
14 * all control traffic via it
15 * General tidy/document
16 * Review the locking/move to refcounts more (mux now moved to an
17 * alloc/free model ready)
18 * Use newest tty open/close port helpers and install hooks
19 * What to do about power functions ?
20 * Termios setting and negotiation
21 * Do we need a 'which mux are you' ioctl to correlate mux and tty sets
25 #include <linux/types.h>
26 #include <linux/major.h>
27 #include <linux/errno.h>
28 #include <linux/signal.h>
29 #include <linux/fcntl.h>
30 #include <linux/sched/signal.h>
31 #include <linux/interrupt.h>
32 #include <linux/tty.h>
33 #include <linux/ctype.h>
35 #include <linux/string.h>
36 #include <linux/slab.h>
37 #include <linux/poll.h>
38 #include <linux/bitops.h>
39 #include <linux/file.h>
40 #include <linux/uaccess.h>
41 #include <linux/module.h>
42 #include <linux/timer.h>
43 #include <linux/tty_flip.h>
44 #include <linux/tty_driver.h>
45 #include <linux/serial.h>
46 #include <linux/kfifo.h>
47 #include <linux/skbuff.h>
50 #include <linux/netdevice.h>
51 #include <linux/etherdevice.h>
52 #include <linux/gsmmux.h>
56 module_param(debug, int, 0600);
58 /* Defaults: these are from the specification */
60 #define T1 10 /* 100mS */
61 #define T2 34 /* 333mS */
62 #define N2 3 /* Retry 3 times */
64 /* Use long timers for testing at low speed with debug on */
71 * Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte
72 * limits so this is plenty
76 /* SOF, ADDR, CTRL, LEN1, LEN2, ..., FCS, EOF */
77 #define PROT_OVERHEAD 7
78 #define GSM_NET_TX_TIMEOUT (HZ*10)
81 * struct gsm_mux_net - network interface
83 * Created when net interface is initialized.
87 struct gsm_dlci *dlci;
91 * Each block of data we have queued to go out is in the form of
92 * a gsm_msg which holds everything we need in a link layer independent
97 struct list_head list;
98 u8 addr; /* DLCI address + flags */
99 u8 ctrl; /* Control byte + flags */
100 unsigned int len; /* Length of data block (can be zero) */
101 unsigned char *data; /* Points into buffer but not at the start */
102 unsigned char buffer[];
105 enum gsm_dlci_state {
107 DLCI_OPENING, /* Sending SABM not seen UA */
108 DLCI_OPEN, /* SABM/UA complete */
109 DLCI_CLOSING, /* Sending DISC not seen UA/DM */
113 DLCI_MODE_ABM, /* Normal Asynchronous Balanced Mode */
114 DLCI_MODE_ADM, /* Asynchronous Disconnected Mode */
118 * Each active data link has a gsm_dlci structure associated which ties
119 * the link layer to an optional tty (if the tty side is open). To avoid
120 * complexity right now these are only ever freed up when the mux is
123 * At the moment we don't free DLCI objects until the mux is torn down
124 * this avoid object life time issues but might be worth review later.
130 enum gsm_dlci_state state;
134 enum gsm_dlci_mode mode;
135 spinlock_t lock; /* Protects the internal state */
136 struct timer_list t1; /* Retransmit timer for SABM and UA */
138 /* Uplink tty if active */
139 struct tty_port port; /* The tty bound to this DLCI if there is one */
140 #define TX_SIZE 4096 /* Must be power of 2. */
141 struct kfifo fifo; /* Queue fifo for the DLCI */
142 int adaption; /* Adaption layer in use */
144 u32 modem_rx; /* Our incoming virtual modem lines */
145 u32 modem_tx; /* Our outgoing modem lines */
146 bool dead; /* Refuse re-open */
148 bool throttled; /* Private copy of throttle state */
149 bool constipated; /* Throttle status for outgoing */
151 struct sk_buff *skb; /* Frame being sent */
152 struct sk_buff_head skb_list; /* Queued frames */
153 /* Data handling callback */
154 void (*data)(struct gsm_dlci *dlci, const u8 *data, int len);
155 void (*prev_data)(struct gsm_dlci *dlci, const u8 *data, int len);
156 struct net_device *net; /* network interface, if created */
159 /* DLCI 0, 62/63 are special or reserved see gsmtty_open */
164 * DLCI 0 is used to pass control blocks out of band of the data
165 * flow (and with a higher link priority). One command can be outstanding
166 * at a time and we use this structure to manage them. They are created
167 * and destroyed by the user context, and updated by the receive paths
172 u8 cmd; /* Command we are issuing */
173 u8 *data; /* Data for the command in case we retransmit */
174 int len; /* Length of block for retransmission */
175 int done; /* Done flag */
176 int error; /* Error if any */
194 * Each GSM mux we have is represented by this structure. If we are
195 * operating as an ldisc then we use this structure as our ldisc
196 * state. We need to sort out lifetimes and locking with respect
197 * to the gsm mux array. For now we don't free DLCI objects that
198 * have been instantiated until the mux itself is terminated.
200 * To consider further: tty open versus mux shutdown.
204 struct tty_struct *tty; /* The tty our ldisc is bound to */
210 /* Events on the GSM channel */
211 wait_queue_head_t event;
213 /* Bits for GSM mode decoding */
217 enum gsm_mux_state state;
219 unsigned int address;
225 u8 *txframe; /* TX framing buffer */
227 /* Method for the receiver side */
228 void (*receive)(struct gsm_mux *gsm, u8 ch);
233 int initiator; /* Did we initiate connection */
234 bool dead; /* Has the mux been shut down */
235 struct gsm_dlci *dlci[NUM_DLCI];
236 int old_c_iflag; /* termios c_iflag value before attach */
237 bool constipated; /* Asked by remote to shut up */
238 bool has_devices; /* Devices were registered */
241 unsigned int tx_bytes; /* TX data outstanding */
242 #define TX_THRESH_HI 8192
243 #define TX_THRESH_LO 2048
244 struct list_head tx_list; /* Pending data packets */
246 /* Control messages */
247 struct timer_list kick_timer; /* Kick TX queuing on timeout */
248 struct timer_list t2_timer; /* Retransmit timer for commands */
249 int cretries; /* Command retry counter */
250 struct gsm_control *pending_cmd;/* Our current pending command */
251 spinlock_t control_lock; /* Protects the pending command */
254 int adaption; /* 1 or 2 supported */
255 u8 ftype; /* UI or UIH */
256 int t1, t2; /* Timers in 1/100th of a sec */
257 int n2; /* Retry count */
259 /* Statistics (not currently exposed) */
260 unsigned long bad_fcs;
261 unsigned long malformed;
262 unsigned long io_error;
263 unsigned long bad_size;
264 unsigned long unsupported;
269 * Mux objects - needed so that we can translate a tty index into the
270 * relevant mux and DLCI.
273 #define MAX_MUX 4 /* 256 minors */
274 static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */
275 static DEFINE_SPINLOCK(gsm_mux_lock);
277 static struct tty_driver *gsm_tty_driver;
279 /* Save dlci open address */
280 static int addr_open[256] = { 0 };
281 /* Save dlci open count */
284 * This section of the driver logic implements the GSM encodings
285 * both the basic and the 'advanced'. Reliable transport is not
293 /* I is special: the rest are ..*/
304 /* Channel commands */
306 #define CMD_TEST 0x11
309 #define CMD_FCOFF 0x31
312 #define CMD_FCON 0x51
317 /* Virtual modem bits */
324 #define GSM0_SOF 0xF9
325 #define GSM1_SOF 0x7E
326 #define GSM1_ESCAPE 0x7D
327 #define GSM1_ESCAPE_BITS 0x20
330 #define ISO_IEC_646_MASK 0x7F
332 static const struct tty_port_operations gsm_port_ops;
335 * CRC table for GSM 0710
338 static const u8 gsm_fcs8[256] = {
339 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
340 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
341 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
342 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
343 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
344 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
345 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
346 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
347 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
348 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
349 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
350 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
351 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
352 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
353 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
354 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
355 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
356 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
357 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
358 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
359 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
360 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
361 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
362 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
363 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
364 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
365 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
366 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
367 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
368 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
369 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
370 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
373 #define INIT_FCS 0xFF
374 #define GOOD_FCS 0xCF
376 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len);
377 static int gsm_modem_update(struct gsm_dlci *dlci, u8 brk);
380 * gsm_fcs_add - update FCS
384 * Update the FCS to include c. Uses the algorithm in the specification
388 static inline u8 gsm_fcs_add(u8 fcs, u8 c)
390 return gsm_fcs8[fcs ^ c];
394 * gsm_fcs_add_block - update FCS for a block
397 * @len: length of buffer
399 * Update the FCS to include c. Uses the algorithm in the specification
403 static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
406 fcs = gsm_fcs8[fcs ^ *c++];
411 * gsm_read_ea - read a byte into an EA
412 * @val: variable holding value
413 * @c: byte going into the EA
415 * Processes one byte of an EA. Updates the passed variable
416 * and returns 1 if the EA is now completely read
419 static int gsm_read_ea(unsigned int *val, u8 c)
421 /* Add the next 7 bits into the value */
424 /* Was this the last byte of the EA 1 = yes*/
429 * gsm_read_ea_val - read a value until EA
430 * @val: variable holding value
431 * @data: buffer of data
432 * @dlen: length of data
434 * Processes an EA value. Updates the passed variable and
435 * returns the processed data length.
437 static unsigned int gsm_read_ea_val(unsigned int *val, const u8 *data, int dlen)
439 unsigned int len = 0;
441 for (; dlen > 0; dlen--) {
443 if (gsm_read_ea(val, *data++))
450 * gsm_encode_modem - encode modem data bits
451 * @dlci: DLCI to encode from
453 * Returns the correct GSM encoded modem status bits (6 bit field) for
454 * the current status of the DLCI and attached tty object
457 static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
460 /* FC is true flow control not modem bits */
463 if (dlci->modem_tx & TIOCM_DTR)
464 modembits |= MDM_RTC;
465 if (dlci->modem_tx & TIOCM_RTS)
466 modembits |= MDM_RTR;
467 if (dlci->modem_tx & TIOCM_RI)
469 if (dlci->modem_tx & TIOCM_CD || dlci->gsm->initiator)
474 static void gsm_hex_dump_bytes(const char *fname, const u8 *data,
480 print_hex_dump(KERN_INFO, "", DUMP_PREFIX_NONE, 16, 1, data, len,
485 prefix = kasprintf(GFP_ATOMIC, "%s: ", fname);
488 print_hex_dump(KERN_INFO, prefix, DUMP_PREFIX_OFFSET, 16, 1, data, len,
494 * gsm_register_devices - register all tty devices for a given mux index
496 * @driver: the tty driver that describes the tty devices
497 * @index: the mux number is used to calculate the minor numbers of the
498 * ttys for this mux and may differ from the position in the
501 static int gsm_register_devices(struct tty_driver *driver, unsigned int index)
507 if (!driver || index >= MAX_MUX)
510 base = index * NUM_DLCI; /* first minor for this index */
511 for (i = 1; i < NUM_DLCI; i++) {
512 /* Don't register device 0 - this is the control channel
513 * and not a usable tty interface
515 dev = tty_register_device(gsm_tty_driver, base + i, NULL);
518 pr_info("%s failed to register device minor %u",
520 for (i--; i >= 1; i--)
521 tty_unregister_device(gsm_tty_driver, base + i);
530 * gsm_unregister_devices - unregister all tty devices for a given mux index
532 * @driver: the tty driver that describes the tty devices
533 * @index: the mux number is used to calculate the minor numbers of the
534 * ttys for this mux and may differ from the position in the
537 static void gsm_unregister_devices(struct tty_driver *driver,
543 if (!driver || index >= MAX_MUX)
546 base = index * NUM_DLCI; /* first minor for this index */
547 for (i = 1; i < NUM_DLCI; i++) {
548 /* Don't unregister device 0 - this is the control
549 * channel and not a usable tty interface
551 tty_unregister_device(gsm_tty_driver, base + i);
556 * gsm_print_packet - display a frame for debug
557 * @hdr: header to print before decode
558 * @addr: address EA from the frame
559 * @cr: C/R bit seen as initiator
560 * @control: control including PF bit
561 * @data: following data bytes
562 * @dlen: length of data
564 * Displays a packet in human readable format for debugging purposes. The
565 * style is based on amateur radio LAP-B dump display.
568 static void gsm_print_packet(const char *hdr, int addr, int cr,
569 u8 control, const u8 *data, int dlen)
574 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
576 switch (control & ~PF) {
596 if (!(control & 0x01)) {
597 pr_cont("I N(S)%d N(R)%d",
598 (control & 0x0E) >> 1, (control & 0xE0) >> 5);
599 } else switch (control & 0x0F) {
601 pr_cont("RR(%d)", (control & 0xE0) >> 5);
604 pr_cont("RNR(%d)", (control & 0xE0) >> 5);
607 pr_cont("REJ(%d)", (control & 0xE0) >> 5);
610 pr_cont("[%02X]", control);
619 gsm_hex_dump_bytes(NULL, data, dlen);
624 * Link level transmission side
628 * gsm_stuff_frame - bytestuff a packet
629 * @input: input buffer
630 * @output: output buffer
631 * @len: length of input
633 * Expand a buffer by bytestuffing it. The worst case size change
634 * is doubling and the caller is responsible for handing out
635 * suitable sized buffers.
638 static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
642 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
643 || (*input & ISO_IEC_646_MASK) == XON
644 || (*input & ISO_IEC_646_MASK) == XOFF) {
645 *output++ = GSM1_ESCAPE;
646 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
649 *output++ = *input++;
656 * gsm_send - send a control frame
658 * @addr: address for control frame
659 * @cr: command/response bit seen as initiator
660 * @control: control byte including PF bit
662 * Format up and transmit a control frame. These do not go via the
663 * queueing logic as they should be transmitted ahead of data when
666 * FIXME: Lock versus data TX path
669 static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
676 /* toggle C/R coding if not initiator */
677 ocr = cr ^ (gsm->initiator ? 0 : 1);
679 switch (gsm->encoding) {
682 cbuf[1] = (addr << 2) | (ocr << 1) | EA;
684 cbuf[3] = EA; /* Length of data = 0 */
685 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
691 /* Control frame + packing (but not frame stuffing) in mode 1 */
692 ibuf[0] = (addr << 2) | (ocr << 1) | EA;
694 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
695 /* Stuffing may double the size worst case */
696 len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
697 /* Now add the SOF markers */
699 cbuf[len + 1] = GSM1_SOF;
700 /* FIXME: we can omit the lead one in many cases */
707 gsmld_output(gsm, cbuf, len);
708 gsm_print_packet("-->", addr, cr, control, NULL, 0);
712 * gsm_response - send a control response
714 * @addr: address for control frame
715 * @control: control byte including PF bit
717 * Format up and transmit a link level response frame.
720 static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
722 gsm_send(gsm, addr, 0, control);
726 * gsm_command - send a control command
728 * @addr: address for control frame
729 * @control: control byte including PF bit
731 * Format up and transmit a link level command frame.
734 static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
736 gsm_send(gsm, addr, 1, control);
739 /* Data transmission */
741 #define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
744 * gsm_data_alloc - allocate data frame
746 * @addr: DLCI address
747 * @len: length excluding header and FCS
748 * @ctrl: control byte
750 * Allocate a new data buffer for sending frames with data. Space is left
751 * at the front for header bytes but that is treated as an implementation
752 * detail and not for the high level code to use
755 static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
758 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
762 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */
766 INIT_LIST_HEAD(&m->list);
771 * gsm_is_flow_ctrl_msg - checks if flow control message
772 * @msg: message to check
774 * Returns true if the given message is a flow control command of the
775 * control channel. False is returned in any other case.
777 static bool gsm_is_flow_ctrl_msg(struct gsm_msg *msg)
784 switch (msg->ctrl & ~PF) {
788 if (gsm_read_ea_val(&cmd, msg->data + 2, msg->len - 2) < 1)
802 * gsm_data_kick - poke the queue
804 * @dlci: DLCI sending the data
806 * The tty device has called us to indicate that room has appeared in
807 * the transmit queue. Ram more data into the pipe if we have any
808 * If we have been flow-stopped by a CMD_FCOFF, then we can only
809 * send messages on DLCI0 until CMD_FCON
811 * FIXME: lock against link layer control transmissions
814 static void gsm_data_kick(struct gsm_mux *gsm, struct gsm_dlci *dlci)
816 struct gsm_msg *msg, *nmsg;
819 list_for_each_entry_safe(msg, nmsg, &gsm->tx_list, list) {
820 if (gsm->constipated && !gsm_is_flow_ctrl_msg(msg))
822 if (gsm->encoding != 0) {
823 gsm->txframe[0] = GSM1_SOF;
824 len = gsm_stuff_frame(msg->data,
825 gsm->txframe + 1, msg->len);
826 gsm->txframe[len + 1] = GSM1_SOF;
829 gsm->txframe[0] = GSM0_SOF;
830 memcpy(gsm->txframe + 1 , msg->data, msg->len);
831 gsm->txframe[msg->len + 1] = GSM0_SOF;
836 gsm_hex_dump_bytes(__func__, gsm->txframe, len);
837 if (gsmld_output(gsm, gsm->txframe, len) <= 0)
839 /* FIXME: Can eliminate one SOF in many more cases */
840 gsm->tx_bytes -= msg->len;
842 list_del(&msg->list);
846 tty_port_tty_wakeup(&dlci->port);
850 for (i = 0; i < NUM_DLCI; i++)
852 tty_port_tty_wakeup(&gsm->dlci[i]->port);
858 * __gsm_data_queue - queue a UI or UIH frame
859 * @dlci: DLCI sending the data
860 * @msg: message queued
862 * Add data to the transmit queue and try and get stuff moving
863 * out of the mux tty if not already doing so. The Caller must hold
867 static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
869 struct gsm_mux *gsm = dlci->gsm;
871 u8 *fcs = dp + msg->len;
873 /* Fill in the header */
874 if (gsm->encoding == 0) {
876 *--dp = (msg->len << 1) | EA;
878 *--dp = (msg->len >> 7); /* bits 7 - 15 */
879 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */
885 *--dp = (msg->addr << 2) | 2 | EA;
887 *--dp = (msg->addr << 2) | EA;
888 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
889 /* Ugly protocol layering violation */
890 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
891 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
894 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
895 msg->data, msg->len);
897 /* Move the header back and adjust the length, also allow for the FCS
898 now tacked on the end */
899 msg->len += (msg->data - dp) + 1;
902 /* Add to the actual output queue */
903 list_add_tail(&msg->list, &gsm->tx_list);
904 gsm->tx_bytes += msg->len;
905 gsm_data_kick(gsm, dlci);
906 mod_timer(&gsm->kick_timer, jiffies + 10 * gsm->t1 * HZ / 100);
910 * gsm_data_queue - queue a UI or UIH frame
911 * @dlci: DLCI sending the data
912 * @msg: message queued
914 * Add data to the transmit queue and try and get stuff moving
915 * out of the mux tty if not already doing so. Take the
916 * the gsm tx lock and dlci lock.
919 static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
922 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
923 __gsm_data_queue(dlci, msg);
924 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
928 * gsm_dlci_data_output - try and push data out of a DLCI
930 * @dlci: the DLCI to pull data from
932 * Pull data from a DLCI and send it into the transmit queue if there
933 * is data. Keep to the MRU of the mux. This path handles the usual tty
934 * interface which is a byte stream with optional modem data.
936 * Caller must hold the tx_lock of the mux.
939 static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
945 /* for modem bits without break data */
946 h = ((dlci->adaption == 1) ? 0 : 1);
948 len = kfifo_len(&dlci->fifo);
952 /* MTU/MRU count only the data bits but watch adaption mode */
953 if ((len + h) > gsm->mtu)
958 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
962 switch (dlci->adaption) {
963 case 1: /* Unstructured */
965 case 2: /* Unstructured with modem bits.
966 * Always one byte as we never send inline break data
968 *dp++ = (gsm_encode_modem(dlci) << 1) | EA;
971 pr_err("%s: unsupported adaption %d\n", __func__,
976 WARN_ON(len != kfifo_out_locked(&dlci->fifo, dp, len,
979 /* Notify upper layer about available send space. */
980 tty_port_tty_wakeup(&dlci->port);
982 __gsm_data_queue(dlci, msg);
983 /* Bytes of data we used up */
988 * gsm_dlci_data_output_framed - try and push data out of a DLCI
990 * @dlci: the DLCI to pull data from
992 * Pull data from a DLCI and send it into the transmit queue if there
993 * is data. Keep to the MRU of the mux. This path handles framed data
994 * queued as skbuffs to the DLCI.
996 * Caller must hold the tx_lock of the mux.
999 static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
1000 struct gsm_dlci *dlci)
1002 struct gsm_msg *msg;
1005 int last = 0, first = 0;
1008 /* One byte per frame is used for B/F flags */
1009 if (dlci->adaption == 4)
1012 /* dlci->skb is locked by tx_lock */
1013 if (dlci->skb == NULL) {
1014 dlci->skb = skb_dequeue_tail(&dlci->skb_list);
1015 if (dlci->skb == NULL)
1019 len = dlci->skb->len + overhead;
1021 /* MTU/MRU count only the data bits */
1022 if (len > gsm->mtu) {
1023 if (dlci->adaption == 3) {
1024 /* Over long frame, bin it */
1025 dev_kfree_skb_any(dlci->skb);
1033 size = len + overhead;
1034 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
1036 skb_queue_tail(&dlci->skb_list, dlci->skb);
1042 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
1043 /* Flag byte to carry the start/end info */
1044 *dp++ = last << 7 | first << 6 | 1; /* EA */
1047 memcpy(dp, dlci->skb->data, len);
1048 skb_pull(dlci->skb, len);
1049 __gsm_data_queue(dlci, msg);
1051 dev_kfree_skb_any(dlci->skb);
1058 * gsm_dlci_modem_output - try and push modem status out of a DLCI
1060 * @dlci: the DLCI to pull modem status from
1061 * @brk: break signal
1063 * Push an empty frame in to the transmit queue to update the modem status
1064 * bits and to transmit an optional break.
1066 * Caller must hold the tx_lock of the mux.
1069 static int gsm_dlci_modem_output(struct gsm_mux *gsm, struct gsm_dlci *dlci,
1073 struct gsm_msg *msg;
1076 /* for modem bits without break data */
1077 switch (dlci->adaption) {
1078 case 1: /* Unstructured */
1080 case 2: /* Unstructured with modem bits. */
1086 pr_err("%s: unsupported adaption %d\n", __func__,
1091 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
1093 pr_err("%s: gsm_data_alloc error", __func__);
1097 switch (dlci->adaption) {
1098 case 1: /* Unstructured */
1100 case 2: /* Unstructured with modem bits. */
1102 *dp++ = (gsm_encode_modem(dlci) << 1) | EA;
1104 *dp++ = gsm_encode_modem(dlci) << 1;
1105 *dp++ = (brk << 4) | 2 | EA; /* Length, Break, EA */
1113 __gsm_data_queue(dlci, msg);
1118 * gsm_dlci_data_sweep - look for data to send
1121 * Sweep the GSM mux channels in priority order looking for ones with
1122 * data to send. We could do with optimising this scan a bit. We aim
1123 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
1124 * TX_THRESH_LO we get called again
1126 * FIXME: We should round robin between groups and in theory you can
1127 * renegotiate DLCI priorities with optional stuff. Needs optimising.
1130 static int gsm_dlci_data_sweep(struct gsm_mux *gsm)
1133 /* Priority ordering: We should do priority with RR of the groups */
1136 while (i < NUM_DLCI) {
1137 struct gsm_dlci *dlci;
1139 if (gsm->tx_bytes > TX_THRESH_HI)
1141 dlci = gsm->dlci[i];
1142 if (dlci == NULL || dlci->constipated) {
1146 if (dlci->adaption < 3 && !dlci->net)
1147 len = gsm_dlci_data_output(gsm, dlci);
1149 len = gsm_dlci_data_output_framed(gsm, dlci);
1152 /* DLCI empty - try the next */
1163 * gsm_dlci_data_kick - transmit if possible
1164 * @dlci: DLCI to kick
1166 * Transmit data from this DLCI if the queue is empty. We can't rely on
1167 * a tty wakeup except when we filled the pipe so we need to fire off
1168 * new data ourselves in other cases.
1171 static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
1173 unsigned long flags;
1176 if (dlci->constipated)
1179 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
1180 /* If we have nothing running then we need to fire up */
1181 sweep = (dlci->gsm->tx_bytes < TX_THRESH_LO);
1182 if (dlci->gsm->tx_bytes == 0) {
1184 gsm_dlci_data_output_framed(dlci->gsm, dlci);
1186 gsm_dlci_data_output(dlci->gsm, dlci);
1189 gsm_dlci_data_sweep(dlci->gsm);
1190 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
1194 * Control message processing
1199 * gsm_control_reply - send a response frame to a control
1201 * @cmd: the command to use
1202 * @data: data to follow encoded info
1203 * @dlen: length of data
1205 * Encode up and queue a UI/UIH frame containing our response.
1208 static void gsm_control_reply(struct gsm_mux *gsm, int cmd, const u8 *data,
1211 struct gsm_msg *msg;
1212 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
1215 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */
1216 msg->data[1] = (dlen << 1) | EA;
1217 memcpy(msg->data + 2, data, dlen);
1218 gsm_data_queue(gsm->dlci[0], msg);
1222 * gsm_process_modem - process received modem status
1223 * @tty: virtual tty bound to the DLCI
1224 * @dlci: DLCI to affect
1225 * @modem: modem bits (full EA)
1226 * @slen: number of signal octets
1228 * Used when a modem control message or line state inline in adaption
1229 * layer 2 is processed. Sort out the local modem state and throttles
1232 static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
1233 u32 modem, int slen)
1239 /* The modem status command can either contain one octet (V.24 signals)
1240 * or two octets (V.24 signals + break signals). This is specified in
1241 * section 5.4.6.3.7 of the 07.10 mux spec.
1245 modem = modem & 0x7f;
1248 modem = (modem >> 7) & 0x7f;
1251 /* Flow control/ready to communicate */
1252 fc = (modem & MDM_FC) || !(modem & MDM_RTR);
1253 if (fc && !dlci->constipated) {
1254 /* Need to throttle our output on this device */
1255 dlci->constipated = true;
1256 } else if (!fc && dlci->constipated) {
1257 dlci->constipated = false;
1258 gsm_dlci_data_kick(dlci);
1261 /* Map modem bits */
1262 if (modem & MDM_RTC)
1263 mlines |= TIOCM_DSR | TIOCM_DTR;
1264 if (modem & MDM_RTR)
1265 mlines |= TIOCM_RTS | TIOCM_CTS;
1271 /* Carrier drop -> hangup */
1273 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1278 tty_insert_flip_char(&dlci->port, 0, TTY_BREAK);
1279 dlci->modem_rx = mlines;
1283 * gsm_control_modem - modem status received
1285 * @data: data following command
1286 * @clen: command length
1288 * We have received a modem status control message. This is used by
1289 * the GSM mux protocol to pass virtual modem line status and optionally
1290 * to indicate break signals. Unpack it, convert to Linux representation
1291 * and if need be stuff a break message down the tty.
1294 static void gsm_control_modem(struct gsm_mux *gsm, const u8 *data, int clen)
1296 unsigned int addr = 0;
1297 unsigned int modem = 0;
1298 struct gsm_dlci *dlci;
1301 const u8 *dp = data;
1302 struct tty_struct *tty;
1304 while (gsm_read_ea(&addr, *dp++) == 0) {
1309 /* Must be at least one byte following the EA */
1315 /* Closed port, or invalid ? */
1316 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1318 dlci = gsm->dlci[addr];
1321 while (gsm_read_ea(&modem, *dp++) == 0) {
1327 tty = tty_port_tty_get(&dlci->port);
1328 gsm_process_modem(tty, dlci, modem, slen - len);
1333 gsm_control_reply(gsm, CMD_MSC, data, clen);
1337 * gsm_control_rls - remote line status
1340 * @clen: data length
1342 * The modem sends us a two byte message on the control channel whenever
1343 * it wishes to send us an error state from the virtual link. Stuff
1344 * this into the uplink tty if present
1347 static void gsm_control_rls(struct gsm_mux *gsm, const u8 *data, int clen)
1349 struct tty_port *port;
1350 unsigned int addr = 0;
1353 const u8 *dp = data;
1355 while (gsm_read_ea(&addr, *dp++) == 0) {
1360 /* Must be at least one byte following ea */
1365 /* Closed port, or invalid ? */
1366 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1370 if ((bits & 1) == 0)
1373 port = &gsm->dlci[addr]->port;
1376 tty_insert_flip_char(port, 0, TTY_OVERRUN);
1378 tty_insert_flip_char(port, 0, TTY_PARITY);
1380 tty_insert_flip_char(port, 0, TTY_FRAME);
1382 tty_flip_buffer_push(port);
1384 gsm_control_reply(gsm, CMD_RLS, data, clen);
1387 static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1388 static void gsm_dlci_close(struct gsm_dlci *dlci);
1391 * gsm_control_message - DLCI 0 control processing
1393 * @command: the command EA
1394 * @data: data beyond the command/length EAs
1397 * Input processor for control messages from the other end of the link.
1398 * Processes the incoming request and queues a response frame or an
1399 * NSC response if not supported
1402 static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1403 const u8 *data, int clen)
1406 unsigned long flags;
1407 struct gsm_dlci *dlci;
1414 for (i = 0; i < addr_cnt; i++) {
1415 address = addr_open[i];
1416 dlci = gsm->dlci[address];
1417 gsm_dlci_close(dlci);
1421 /* Modem wishes to close down */
1422 dlci = gsm->dlci[0];
1426 gsm_dlci_close(dlci);
1428 gsm_response(gsm, 0, UA|PF);
1433 /* Modem wishes to test, reply with the data */
1434 gsm_control_reply(gsm, CMD_TEST, data, clen);
1437 /* Modem can accept data again */
1438 gsm->constipated = false;
1439 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1440 /* Kick the link in case it is idling */
1441 spin_lock_irqsave(&gsm->tx_lock, flags);
1442 gsm_data_kick(gsm, NULL);
1443 spin_unlock_irqrestore(&gsm->tx_lock, flags);
1446 /* Modem wants us to STFU */
1447 gsm->constipated = true;
1448 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1451 /* Out of band modem line change indicator for a DLCI */
1452 gsm_control_modem(gsm, data, clen);
1455 /* Out of band error reception for a DLCI */
1456 gsm_control_rls(gsm, data, clen);
1459 /* Modem wishes to enter power saving state */
1460 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1462 /* Optional unsupported commands */
1463 case CMD_PN: /* Parameter negotiation */
1464 case CMD_RPN: /* Remote port negotiation */
1465 case CMD_SNC: /* Service negotiation command */
1467 /* Reply to bad commands with an NSC */
1469 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1475 * gsm_control_response - process a response to our control
1477 * @command: the command (response) EA
1478 * @data: data beyond the command/length EA
1481 * Process a response to an outstanding command. We only allow a single
1482 * control message in flight so this is fairly easy. All the clean up
1483 * is done by the caller, we just update the fields, flag it as done
1487 static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1488 const u8 *data, int clen)
1490 struct gsm_control *ctrl;
1491 unsigned long flags;
1493 spin_lock_irqsave(&gsm->control_lock, flags);
1495 ctrl = gsm->pending_cmd;
1496 /* Does the reply match our command */
1498 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1499 /* Our command was replied to, kill the retry timer */
1500 del_timer(&gsm->t2_timer);
1501 gsm->pending_cmd = NULL;
1502 /* Rejected by the other end */
1503 if (command == CMD_NSC)
1504 ctrl->error = -EOPNOTSUPP;
1506 wake_up(&gsm->event);
1508 spin_unlock_irqrestore(&gsm->control_lock, flags);
1512 * gsm_control_transmit - send control packet
1514 * @ctrl: frame to send
1516 * Send out a pending control command (called under control lock)
1519 static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1521 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 2, gsm->ftype);
1524 msg->data[0] = (ctrl->cmd << 1) | CR | EA; /* command */
1525 msg->data[1] = (ctrl->len << 1) | EA;
1526 memcpy(msg->data + 2, ctrl->data, ctrl->len);
1527 gsm_data_queue(gsm->dlci[0], msg);
1531 * gsm_control_retransmit - retransmit a control frame
1532 * @t: timer contained in our gsm object
1534 * Called off the T2 timer expiry in order to retransmit control frames
1535 * that have been lost in the system somewhere. The control_lock protects
1536 * us from colliding with another sender or a receive completion event.
1537 * In that situation the timer may still occur in a small window but
1538 * gsm->pending_cmd will be NULL and we just let the timer expire.
1541 static void gsm_control_retransmit(struct timer_list *t)
1543 struct gsm_mux *gsm = from_timer(gsm, t, t2_timer);
1544 struct gsm_control *ctrl;
1545 unsigned long flags;
1546 spin_lock_irqsave(&gsm->control_lock, flags);
1547 ctrl = gsm->pending_cmd;
1549 if (gsm->cretries == 0 || !gsm->dlci[0] || gsm->dlci[0]->dead) {
1550 gsm->pending_cmd = NULL;
1551 ctrl->error = -ETIMEDOUT;
1553 spin_unlock_irqrestore(&gsm->control_lock, flags);
1554 wake_up(&gsm->event);
1558 gsm_control_transmit(gsm, ctrl);
1559 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1561 spin_unlock_irqrestore(&gsm->control_lock, flags);
1565 * gsm_control_send - send a control frame on DLCI 0
1566 * @gsm: the GSM channel
1567 * @command: command to send including CR bit
1568 * @data: bytes of data (must be kmalloced)
1569 * @clen: length of the block to send
1571 * Queue and dispatch a control command. Only one command can be
1572 * active at a time. In theory more can be outstanding but the matching
1573 * gets really complicated so for now stick to one outstanding.
1576 static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1577 unsigned int command, u8 *data, int clen)
1579 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1581 unsigned long flags;
1585 wait_event(gsm->event, gsm->pending_cmd == NULL);
1586 spin_lock_irqsave(&gsm->control_lock, flags);
1587 if (gsm->pending_cmd != NULL) {
1588 spin_unlock_irqrestore(&gsm->control_lock, flags);
1591 ctrl->cmd = command;
1594 gsm->pending_cmd = ctrl;
1596 /* If DLCI0 is in ADM mode skip retries, it won't respond */
1597 if (gsm->dlci[0]->mode == DLCI_MODE_ADM)
1600 gsm->cretries = gsm->n2;
1602 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1603 gsm_control_transmit(gsm, ctrl);
1604 spin_unlock_irqrestore(&gsm->control_lock, flags);
1609 * gsm_control_wait - wait for a control to finish
1611 * @control: control we are waiting on
1613 * Waits for the control to complete or time out. Frees any used
1614 * resources and returns 0 for success, or an error if the remote
1615 * rejected or ignored the request.
1618 static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1621 wait_event(gsm->event, control->done == 1);
1622 err = control->error;
1629 * DLCI level handling: Needs krefs
1633 * State transitions and timers
1637 * gsm_dlci_close - a DLCI has closed
1638 * @dlci: DLCI that closed
1640 * Perform processing when moving a DLCI into closed state. If there
1641 * is an attached tty this is hung up
1644 static void gsm_dlci_close(struct gsm_dlci *dlci)
1646 unsigned long flags;
1648 del_timer(&dlci->t1);
1650 pr_debug("DLCI %d goes closed.\n", dlci->addr);
1651 dlci->state = DLCI_CLOSED;
1652 /* Prevent us from sending data before the link is up again */
1653 dlci->constipated = true;
1654 if (dlci->addr != 0) {
1655 tty_port_tty_hangup(&dlci->port, false);
1656 spin_lock_irqsave(&dlci->lock, flags);
1657 kfifo_reset(&dlci->fifo);
1658 spin_unlock_irqrestore(&dlci->lock, flags);
1659 /* Ensure that gsmtty_open() can return. */
1660 tty_port_set_initialized(&dlci->port, 0);
1661 wake_up_interruptible(&dlci->port.open_wait);
1663 dlci->gsm->dead = true;
1664 wake_up(&dlci->gsm->event);
1665 /* A DLCI 0 close is a MUX termination so we need to kick that
1666 back to userspace somehow */
1670 * gsm_dlci_open - a DLCI has opened
1671 * @dlci: DLCI that opened
1673 * Perform processing when moving a DLCI into open state.
1676 static void gsm_dlci_open(struct gsm_dlci *dlci)
1678 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1680 del_timer(&dlci->t1);
1681 /* This will let a tty open continue */
1682 dlci->state = DLCI_OPEN;
1683 dlci->constipated = false;
1685 pr_debug("DLCI %d goes open.\n", dlci->addr);
1686 /* Send current modem state */
1688 gsm_modem_update(dlci, 0);
1689 wake_up(&dlci->gsm->event);
1693 * gsm_dlci_t1 - T1 timer expiry
1694 * @t: timer contained in the DLCI that opened
1696 * The T1 timer handles retransmits of control frames (essentially of
1697 * SABM and DISC). We resend the command until the retry count runs out
1698 * in which case an opening port goes back to closed and a closing port
1699 * is simply put into closed state (any further frames from the other
1700 * end will get a DM response)
1702 * Some control dlci can stay in ADM mode with other dlci working just
1703 * fine. In that case we can just keep the control dlci open after the
1704 * DLCI_OPENING retries time out.
1707 static void gsm_dlci_t1(struct timer_list *t)
1709 struct gsm_dlci *dlci = from_timer(dlci, t, t1);
1710 struct gsm_mux *gsm = dlci->gsm;
1712 switch (dlci->state) {
1714 if (dlci->retries) {
1716 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1717 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1718 } else if (!dlci->addr && gsm->control == (DM | PF)) {
1720 pr_info("DLCI %d opening in ADM mode.\n",
1722 dlci->mode = DLCI_MODE_ADM;
1723 gsm_dlci_open(dlci);
1725 gsm_dlci_begin_close(dlci); /* prevent half open link */
1730 if (dlci->retries) {
1732 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1733 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1735 gsm_dlci_close(dlci);
1738 pr_debug("%s: unhandled state: %d\n", __func__, dlci->state);
1744 * gsm_dlci_begin_open - start channel open procedure
1745 * @dlci: DLCI to open
1747 * Commence opening a DLCI from the Linux side. We issue SABM messages
1748 * to the modem which should then reply with a UA or ADM, at which point
1749 * we will move into open state. Opening is done asynchronously with retry
1750 * running off timers and the responses.
1753 static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1755 struct gsm_mux *gsm = dlci->gsm;
1756 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1758 dlci->retries = gsm->n2;
1759 dlci->state = DLCI_OPENING;
1760 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1761 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1765 * gsm_dlci_set_opening - change state to opening
1766 * @dlci: DLCI to open
1768 * Change internal state to wait for DLCI open from initiator side.
1769 * We set off timers and responses upon reception of an SABM.
1771 static void gsm_dlci_set_opening(struct gsm_dlci *dlci)
1773 switch (dlci->state) {
1776 dlci->state = DLCI_OPENING;
1784 * gsm_dlci_begin_close - start channel open procedure
1785 * @dlci: DLCI to open
1787 * Commence closing a DLCI from the Linux side. We issue DISC messages
1788 * to the modem which should then reply with a UA, at which point we
1789 * will move into closed state. Closing is done asynchronously with retry
1790 * off timers. We may also receive a DM reply from the other end which
1791 * indicates the channel was already closed.
1794 static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1796 struct gsm_mux *gsm = dlci->gsm;
1797 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1799 dlci->retries = gsm->n2;
1800 dlci->state = DLCI_CLOSING;
1801 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1802 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1806 * gsm_dlci_data - data arrived
1808 * @data: block of bytes received
1809 * @clen: length of received block
1811 * A UI or UIH frame has arrived which contains data for a channel
1812 * other than the control channel. If the relevant virtual tty is
1813 * open we shovel the bits down it, if not we drop them.
1816 static void gsm_dlci_data(struct gsm_dlci *dlci, const u8 *data, int clen)
1819 struct tty_port *port = &dlci->port;
1820 struct tty_struct *tty;
1821 unsigned int modem = 0;
1826 pr_debug("%d bytes for tty\n", len);
1827 switch (dlci->adaption) {
1828 /* Unsupported types */
1829 case 4: /* Packetised interruptible data */
1831 case 3: /* Packetised uininterruptible voice/data */
1833 case 2: /* Asynchronous serial with line state in each frame */
1834 while (gsm_read_ea(&modem, *data++) == 0) {
1842 tty = tty_port_tty_get(port);
1844 gsm_process_modem(tty, dlci, modem, slen);
1849 case 1: /* Line state will go via DLCI 0 controls only */
1851 tty_insert_flip_string(port, data, len);
1852 tty_flip_buffer_push(port);
1857 * gsm_dlci_command - data arrived on control channel
1859 * @data: block of bytes received
1860 * @len: length of received block
1862 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1863 * control channel. This should contain a command EA followed by
1864 * control data bytes. The command EA contains a command/response bit
1865 * and we divide up the work accordingly.
1868 static void gsm_dlci_command(struct gsm_dlci *dlci, const u8 *data, int len)
1870 /* See what command is involved */
1871 unsigned int command = 0;
1873 if (gsm_read_ea(&command, *data++) == 1) {
1876 /* FIXME: this is properly an EA */
1878 /* Malformed command ? */
1882 gsm_control_message(dlci->gsm, command,
1885 gsm_control_response(dlci->gsm, command,
1893 * gsm_kick_timer - transmit if possible
1894 * @t: timer contained in our gsm object
1896 * Transmit data from DLCIs if the queue is empty. We can't rely on
1897 * a tty wakeup except when we filled the pipe so we need to fire off
1898 * new data ourselves in other cases.
1900 static void gsm_kick_timer(struct timer_list *t)
1902 struct gsm_mux *gsm = from_timer(gsm, t, kick_timer);
1903 unsigned long flags;
1906 spin_lock_irqsave(&gsm->tx_lock, flags);
1907 /* If we have nothing running then we need to fire up */
1908 if (gsm->tx_bytes < TX_THRESH_LO)
1909 sent = gsm_dlci_data_sweep(gsm);
1910 spin_unlock_irqrestore(&gsm->tx_lock, flags);
1912 if (sent && debug & 4)
1913 pr_info("%s TX queue stalled\n", __func__);
1917 * Allocate/Free DLCI channels
1921 * gsm_dlci_alloc - allocate a DLCI
1923 * @addr: address of the DLCI
1925 * Allocate and install a new DLCI object into the GSM mux.
1927 * FIXME: review locking races
1930 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1932 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1935 spin_lock_init(&dlci->lock);
1936 mutex_init(&dlci->mutex);
1937 if (kfifo_alloc(&dlci->fifo, TX_SIZE, GFP_KERNEL) < 0) {
1942 skb_queue_head_init(&dlci->skb_list);
1943 timer_setup(&dlci->t1, gsm_dlci_t1, 0);
1944 tty_port_init(&dlci->port);
1945 dlci->port.ops = &gsm_port_ops;
1948 dlci->adaption = gsm->adaption;
1949 dlci->state = DLCI_CLOSED;
1951 dlci->data = gsm_dlci_data;
1952 /* Prevent us from sending data before the link is up */
1953 dlci->constipated = true;
1955 dlci->data = gsm_dlci_command;
1957 gsm->dlci[addr] = dlci;
1962 * gsm_dlci_free - free DLCI
1963 * @port: tty port for DLCI to free
1969 static void gsm_dlci_free(struct tty_port *port)
1971 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
1973 del_timer_sync(&dlci->t1);
1974 dlci->gsm->dlci[dlci->addr] = NULL;
1975 kfifo_free(&dlci->fifo);
1976 while ((dlci->skb = skb_dequeue(&dlci->skb_list)))
1977 dev_kfree_skb(dlci->skb);
1981 static inline void dlci_get(struct gsm_dlci *dlci)
1983 tty_port_get(&dlci->port);
1986 static inline void dlci_put(struct gsm_dlci *dlci)
1988 tty_port_put(&dlci->port);
1991 static void gsm_destroy_network(struct gsm_dlci *dlci);
1994 * gsm_dlci_release - release DLCI
1995 * @dlci: DLCI to destroy
1997 * Release a DLCI. Actual free is deferred until either
1998 * mux is closed or tty is closed - whichever is last.
2002 static void gsm_dlci_release(struct gsm_dlci *dlci)
2004 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
2006 mutex_lock(&dlci->mutex);
2007 gsm_destroy_network(dlci);
2008 mutex_unlock(&dlci->mutex);
2010 /* We cannot use tty_hangup() because in tty_kref_put() the tty
2011 * driver assumes that the hangup queue is free and reuses it to
2012 * queue release_one_tty() -> NULL pointer panic in
2013 * process_one_work().
2017 tty_port_tty_set(&dlci->port, NULL);
2020 dlci->state = DLCI_CLOSED;
2025 * LAPBish link layer logic
2029 * gsm_queue - a GSM frame is ready to process
2030 * @gsm: pointer to our gsm mux
2032 * At this point in time a frame has arrived and been demangled from
2033 * the line encoding. All the differences between the encodings have
2034 * been handled below us and the frame is unpacked into the structures.
2035 * The fcs holds the header FCS but any data FCS must be added here.
2038 static void gsm_queue(struct gsm_mux *gsm)
2040 struct gsm_dlci *dlci;
2043 int i, j, k, address_tmp;
2045 if (gsm->fcs != GOOD_FCS) {
2048 pr_debug("BAD FCS %02x\n", gsm->fcs);
2051 address = gsm->address >> 1;
2052 if (address >= NUM_DLCI)
2055 cr = gsm->address & 1; /* C/R bit */
2056 cr ^= gsm->initiator ? 0 : 1; /* Flip so 1 always means command */
2058 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
2060 dlci = gsm->dlci[address];
2062 switch (gsm->control) {
2067 dlci = gsm_dlci_alloc(gsm, address);
2071 gsm_response(gsm, address, DM|PF);
2073 gsm_response(gsm, address, UA|PF);
2074 gsm_dlci_open(dlci);
2075 /* Save dlci open address */
2077 addr_open[addr_cnt] = address;
2085 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
2086 gsm_response(gsm, address, DM|PF);
2089 /* Real close complete */
2092 for (i = 0; i < addr_cnt; i++) {
2093 address = addr_open[i];
2094 dlci = gsm->dlci[address];
2095 gsm_dlci_close(dlci);
2099 dlci = gsm->dlci[0];
2100 gsm_dlci_close(dlci);
2102 gsm_response(gsm, 0, UA|PF);
2104 gsm_response(gsm, address, UA|PF);
2105 gsm_dlci_close(dlci);
2106 /* clear dlci address */
2107 for (j = 0; j < addr_cnt; j++) {
2108 address_tmp = addr_open[j];
2109 if (address_tmp == address) {
2110 for (k = j; k < addr_cnt; k++)
2111 addr_open[k] = addr_open[k+1];
2119 if (cr == 0 || dlci == NULL)
2121 switch (dlci->state) {
2123 gsm_dlci_close(dlci);
2126 gsm_dlci_open(dlci);
2129 pr_debug("%s: unhandled state: %d\n", __func__,
2134 case DM: /* DM can be valid unsolicited */
2140 gsm_dlci_close(dlci);
2150 if (dlci == NULL || dlci->state != DLCI_OPEN) {
2151 gsm_response(gsm, address, DM|PF);
2154 dlci->data(dlci, gsm->buf, gsm->len);
2167 * gsm0_receive - perform processing for non-transparency
2168 * @gsm: gsm data for this ldisc instance
2171 * Receive bytes in gsm mode 0
2174 static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
2178 switch (gsm->state) {
2179 case GSM_SEARCH: /* SOF marker */
2180 if (c == GSM0_SOF) {
2181 gsm->state = GSM_ADDRESS;
2184 gsm->fcs = INIT_FCS;
2187 case GSM_ADDRESS: /* Address EA */
2188 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
2189 if (gsm_read_ea(&gsm->address, c))
2190 gsm->state = GSM_CONTROL;
2192 case GSM_CONTROL: /* Control Byte */
2193 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
2195 gsm->state = GSM_LEN0;
2197 case GSM_LEN0: /* Length EA */
2198 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
2199 if (gsm_read_ea(&gsm->len, c)) {
2200 if (gsm->len > gsm->mru) {
2202 gsm->state = GSM_SEARCH;
2207 gsm->state = GSM_FCS;
2209 gsm->state = GSM_DATA;
2212 gsm->state = GSM_LEN1;
2215 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
2217 gsm->len |= len << 7;
2218 if (gsm->len > gsm->mru) {
2220 gsm->state = GSM_SEARCH;
2225 gsm->state = GSM_FCS;
2227 gsm->state = GSM_DATA;
2229 case GSM_DATA: /* Data */
2230 gsm->buf[gsm->count++] = c;
2231 if (gsm->count == gsm->len) {
2232 /* Calculate final FCS for UI frames over all data */
2233 if ((gsm->control & ~PF) != UIH) {
2234 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf,
2237 gsm->state = GSM_FCS;
2240 case GSM_FCS: /* FCS follows the packet */
2241 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
2242 gsm->state = GSM_SSOF;
2245 gsm->state = GSM_SEARCH;
2252 pr_debug("%s: unhandled state: %d\n", __func__, gsm->state);
2258 * gsm1_receive - perform processing for non-transparency
2259 * @gsm: gsm data for this ldisc instance
2262 * Receive bytes in mode 1 (Advanced option)
2265 static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
2267 /* handle XON/XOFF */
2268 if ((c & ISO_IEC_646_MASK) == XON) {
2269 gsm->constipated = true;
2271 } else if ((c & ISO_IEC_646_MASK) == XOFF) {
2272 gsm->constipated = false;
2273 /* Kick the link in case it is idling */
2274 gsm_data_kick(gsm, NULL);
2277 if (c == GSM1_SOF) {
2278 /* EOF is only valid in frame if we have got to the data state */
2279 if (gsm->state == GSM_DATA) {
2280 if (gsm->count < 1) {
2283 gsm->state = GSM_START;
2286 /* Remove the FCS from data */
2288 if ((gsm->control & ~PF) != UIH) {
2289 /* Calculate final FCS for UI frames over all
2292 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf,
2295 /* Add the FCS itself to test against GOOD_FCS */
2296 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
2297 gsm->len = gsm->count;
2299 gsm->state = GSM_START;
2302 /* Any partial frame was a runt so go back to start */
2303 if (gsm->state != GSM_START) {
2304 if (gsm->state != GSM_SEARCH)
2306 gsm->state = GSM_START;
2308 /* A SOF in GSM_START means we are still reading idling or
2313 if (c == GSM1_ESCAPE) {
2318 /* Only an unescaped SOF gets us out of GSM search */
2319 if (gsm->state == GSM_SEARCH)
2323 c ^= GSM1_ESCAPE_BITS;
2324 gsm->escape = false;
2326 switch (gsm->state) {
2327 case GSM_START: /* First byte after SOF */
2329 gsm->state = GSM_ADDRESS;
2330 gsm->fcs = INIT_FCS;
2332 case GSM_ADDRESS: /* Address continuation */
2333 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
2334 if (gsm_read_ea(&gsm->address, c))
2335 gsm->state = GSM_CONTROL;
2337 case GSM_CONTROL: /* Control Byte */
2338 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
2341 gsm->state = GSM_DATA;
2343 case GSM_DATA: /* Data */
2344 if (gsm->count > gsm->mru) { /* Allow one for the FCS */
2345 gsm->state = GSM_OVERRUN;
2348 gsm->buf[gsm->count++] = c;
2350 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */
2353 pr_debug("%s: unhandled state: %d\n", __func__, gsm->state);
2359 * gsm_error - handle tty error
2361 * @data: byte received (may be invalid)
2362 * @flag: error received
2364 * Handle an error in the receipt of data for a frame. Currently we just
2365 * go back to hunting for a SOF.
2367 * FIXME: better diagnostics ?
2370 static void gsm_error(struct gsm_mux *gsm,
2371 unsigned char data, unsigned char flag)
2373 gsm->state = GSM_SEARCH;
2378 * gsm_cleanup_mux - generic GSM protocol cleanup
2380 * @disc: disconnect link?
2382 * Clean up the bits of the mux which are the same for all framing
2383 * protocols. Remove the mux from the mux table, stop all the timers
2384 * and then shut down each device hanging up the channels as we go.
2387 static void gsm_cleanup_mux(struct gsm_mux *gsm, bool disc)
2390 struct gsm_dlci *dlci = gsm->dlci[0];
2391 struct gsm_msg *txq, *ntxq;
2394 mutex_lock(&gsm->mutex);
2397 if (disc && dlci->state != DLCI_CLOSED) {
2398 gsm_dlci_begin_close(dlci);
2399 wait_event(gsm->event, dlci->state == DLCI_CLOSED);
2404 /* Finish outstanding timers, making sure they are done */
2405 del_timer_sync(&gsm->kick_timer);
2406 del_timer_sync(&gsm->t2_timer);
2408 /* Free up any link layer users and finally the control channel */
2409 if (gsm->has_devices) {
2410 gsm_unregister_devices(gsm_tty_driver, gsm->num);
2411 gsm->has_devices = false;
2413 for (i = NUM_DLCI - 1; i >= 0; i--)
2415 gsm_dlci_release(gsm->dlci[i]);
2416 mutex_unlock(&gsm->mutex);
2417 /* Now wipe the queues */
2418 tty_ldisc_flush(gsm->tty);
2419 list_for_each_entry_safe(txq, ntxq, &gsm->tx_list, list)
2421 INIT_LIST_HEAD(&gsm->tx_list);
2425 * gsm_activate_mux - generic GSM setup
2428 * Set up the bits of the mux which are the same for all framing
2429 * protocols. Add the mux to the mux table so it can be opened and
2430 * finally kick off connecting to DLCI 0 on the modem.
2433 static int gsm_activate_mux(struct gsm_mux *gsm)
2435 struct gsm_dlci *dlci;
2438 dlci = gsm_dlci_alloc(gsm, 0);
2442 timer_setup(&gsm->kick_timer, gsm_kick_timer, 0);
2443 timer_setup(&gsm->t2_timer, gsm_control_retransmit, 0);
2444 init_waitqueue_head(&gsm->event);
2445 spin_lock_init(&gsm->control_lock);
2446 spin_lock_init(&gsm->tx_lock);
2448 if (gsm->encoding == 0)
2449 gsm->receive = gsm0_receive;
2451 gsm->receive = gsm1_receive;
2453 ret = gsm_register_devices(gsm_tty_driver, gsm->num);
2457 gsm->has_devices = true;
2458 gsm->dead = false; /* Tty opens are now permissible */
2463 * gsm_free_mux - free up a mux
2466 * Dispose of allocated resources for a dead mux
2468 static void gsm_free_mux(struct gsm_mux *gsm)
2472 for (i = 0; i < MAX_MUX; i++) {
2473 if (gsm == gsm_mux[i]) {
2478 mutex_destroy(&gsm->mutex);
2479 kfree(gsm->txframe);
2485 * gsm_free_muxr - free up a mux
2486 * @ref: kreference to the mux to free
2488 * Dispose of allocated resources for a dead mux
2490 static void gsm_free_muxr(struct kref *ref)
2492 struct gsm_mux *gsm = container_of(ref, struct gsm_mux, ref);
2496 static inline void mux_get(struct gsm_mux *gsm)
2498 unsigned long flags;
2500 spin_lock_irqsave(&gsm_mux_lock, flags);
2501 kref_get(&gsm->ref);
2502 spin_unlock_irqrestore(&gsm_mux_lock, flags);
2505 static inline void mux_put(struct gsm_mux *gsm)
2507 unsigned long flags;
2509 spin_lock_irqsave(&gsm_mux_lock, flags);
2510 kref_put(&gsm->ref, gsm_free_muxr);
2511 spin_unlock_irqrestore(&gsm_mux_lock, flags);
2514 static inline unsigned int mux_num_to_base(struct gsm_mux *gsm)
2516 return gsm->num * NUM_DLCI;
2519 static inline unsigned int mux_line_to_num(unsigned int line)
2521 return line / NUM_DLCI;
2525 * gsm_alloc_mux - allocate a mux
2527 * Creates a new mux ready for activation.
2530 static struct gsm_mux *gsm_alloc_mux(void)
2533 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2536 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2537 if (gsm->buf == NULL) {
2541 gsm->txframe = kmalloc(2 * (MAX_MTU + PROT_OVERHEAD - 1), GFP_KERNEL);
2542 if (gsm->txframe == NULL) {
2547 spin_lock_init(&gsm->lock);
2548 mutex_init(&gsm->mutex);
2549 kref_init(&gsm->ref);
2550 INIT_LIST_HEAD(&gsm->tx_list);
2558 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
2560 gsm->dead = true; /* Avoid early tty opens */
2562 /* Store the instance to the mux array or abort if no space is
2565 spin_lock(&gsm_mux_lock);
2566 for (i = 0; i < MAX_MUX; i++) {
2573 spin_unlock(&gsm_mux_lock);
2575 mutex_destroy(&gsm->mutex);
2576 kfree(gsm->txframe);
2585 static void gsm_copy_config_values(struct gsm_mux *gsm,
2586 struct gsm_config *c)
2588 memset(c, 0, sizeof(*c));
2589 c->adaption = gsm->adaption;
2590 c->encapsulation = gsm->encoding;
2591 c->initiator = gsm->initiator;
2594 c->t3 = 0; /* Not supported */
2596 if (gsm->ftype == UIH)
2600 pr_debug("Ftype %d i %d\n", gsm->ftype, c->i);
2606 static int gsm_config(struct gsm_mux *gsm, struct gsm_config *c)
2610 int need_restart = 0;
2612 /* Stuff we don't support yet - UI or I frame transport, windowing */
2613 if ((c->adaption != 1 && c->adaption != 2) || c->k)
2615 /* Check the MRU/MTU range looks sane */
2616 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2620 if (c->encapsulation > 1) /* Basic, advanced, no I */
2622 if (c->initiator > 1)
2624 if (c->i == 0 || c->i > 2) /* UIH and UI only */
2627 * See what is needed for reconfiguration
2631 if (c->t1 != 0 && c->t1 != gsm->t1)
2633 if (c->t2 != 0 && c->t2 != gsm->t2)
2635 if (c->encapsulation != gsm->encoding)
2637 if (c->adaption != gsm->adaption)
2640 if (c->initiator != gsm->initiator)
2642 if (c->mru != gsm->mru)
2644 if (c->mtu != gsm->mtu)
2648 * Close down what is needed, restart and initiate the new
2649 * configuration. On the first time there is no DLCI[0]
2650 * and closing or cleaning up is not necessary.
2652 if (need_close || need_restart)
2653 gsm_cleanup_mux(gsm, true);
2655 gsm->initiator = c->initiator;
2658 gsm->encoding = c->encapsulation;
2659 gsm->adaption = c->adaption;
2673 * FIXME: We need to separate activation/deactivation from adding
2674 * and removing from the mux array
2677 ret = gsm_activate_mux(gsm);
2681 gsm_dlci_begin_open(gsm->dlci[0]);
2687 * gsmld_output - write to link
2689 * @data: bytes to output
2692 * Write a block of data from the GSM mux to the data channel. This
2693 * will eventually be serialized from above but at the moment isn't.
2696 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2698 if (tty_write_room(gsm->tty) < len) {
2699 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2703 gsm_hex_dump_bytes(__func__, data, len);
2704 return gsm->tty->ops->write(gsm->tty, data, len);
2708 * gsmld_attach_gsm - mode set up
2709 * @tty: our tty structure
2712 * Set up the MUX for basic mode and commence connecting to the
2713 * modem. Currently called from the line discipline set up but
2714 * will need moving to an ioctl path.
2717 static void gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2719 gsm->tty = tty_kref_get(tty);
2720 /* Turn off tty XON/XOFF handling to handle it explicitly. */
2721 gsm->old_c_iflag = tty->termios.c_iflag;
2722 tty->termios.c_iflag &= (IXON | IXOFF);
2726 * gsmld_detach_gsm - stop doing 0710 mux
2727 * @tty: tty attached to the mux
2730 * Shutdown and then clean up the resources used by the line discipline
2733 static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2735 WARN_ON(tty != gsm->tty);
2736 /* Restore tty XON/XOFF handling. */
2737 gsm->tty->termios.c_iflag = gsm->old_c_iflag;
2738 tty_kref_put(gsm->tty);
2742 static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2743 const char *fp, int count)
2745 struct gsm_mux *gsm = tty->disc_data;
2746 char flags = TTY_NORMAL;
2749 gsm_hex_dump_bytes(__func__, cp, count);
2751 for (; count; count--, cp++) {
2757 gsm->receive(gsm, *cp);
2763 gsm_error(gsm, *cp, flags);
2766 WARN_ONCE(1, "%s: unknown flag %d\n",
2767 tty_name(tty), flags);
2771 /* FASYNC if needed ? */
2772 /* If clogged call tty_throttle(tty); */
2776 * gsmld_flush_buffer - clean input queue
2777 * @tty: terminal device
2779 * Flush the input buffer. Called when the line discipline is
2780 * being closed, when the tty layer wants the buffer flushed (eg
2784 static void gsmld_flush_buffer(struct tty_struct *tty)
2789 * gsmld_close - close the ldisc for this tty
2792 * Called from the terminal layer when this line discipline is
2793 * being shut down, either because of a close or becsuse of a
2794 * discipline change. The function will not be called while other
2795 * ldisc methods are in progress.
2798 static void gsmld_close(struct tty_struct *tty)
2800 struct gsm_mux *gsm = tty->disc_data;
2802 /* The ldisc locks and closes the port before calling our close. This
2803 * means we have no way to do a proper disconnect. We will not bother
2806 gsm_cleanup_mux(gsm, false);
2808 gsmld_detach_gsm(tty, gsm);
2810 gsmld_flush_buffer(tty);
2811 /* Do other clean up here */
2816 * gsmld_open - open an ldisc
2817 * @tty: terminal to open
2819 * Called when this line discipline is being attached to the
2820 * terminal device. Can sleep. Called serialized so that no
2821 * other events will occur in parallel. No further open will occur
2825 static int gsmld_open(struct tty_struct *tty)
2827 struct gsm_mux *gsm;
2829 if (tty->ops->write == NULL)
2832 /* Attach our ldisc data */
2833 gsm = gsm_alloc_mux();
2837 tty->disc_data = gsm;
2838 tty->receive_room = 65536;
2840 /* Attach the initial passive connection */
2843 gsmld_attach_gsm(tty, gsm);
2845 timer_setup(&gsm->kick_timer, gsm_kick_timer, 0);
2846 timer_setup(&gsm->t2_timer, gsm_control_retransmit, 0);
2852 * gsmld_write_wakeup - asynchronous I/O notifier
2855 * Required for the ptys, serial driver etc. since processes
2856 * that attach themselves to the master and rely on ASYNC
2857 * IO must be woken up
2860 static void gsmld_write_wakeup(struct tty_struct *tty)
2862 struct gsm_mux *gsm = tty->disc_data;
2863 unsigned long flags;
2866 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2867 spin_lock_irqsave(&gsm->tx_lock, flags);
2868 gsm_data_kick(gsm, NULL);
2869 if (gsm->tx_bytes < TX_THRESH_LO) {
2870 gsm_dlci_data_sweep(gsm);
2872 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2876 * gsmld_read - read function for tty
2878 * @file: file object
2879 * @buf: userspace buffer pointer
2884 * Perform reads for the line discipline. We are guaranteed that the
2885 * line discipline will not be closed under us but we may get multiple
2886 * parallel readers and must handle this ourselves. We may also get
2887 * a hangup. Always called in user context, may sleep.
2889 * This code must be sure never to sleep through a hangup.
2892 static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2893 unsigned char *buf, size_t nr,
2894 void **cookie, unsigned long offset)
2900 * gsmld_write - write function for tty
2902 * @file: file object
2903 * @buf: userspace buffer pointer
2906 * Called when the owner of the device wants to send a frame
2907 * itself (or some other control data). The data is transferred
2908 * as-is and must be properly framed and checksummed as appropriate
2909 * by userspace. Frames are either sent whole or not at all as this
2910 * avoids pain user side.
2913 static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2914 const unsigned char *buf, size_t nr)
2916 struct gsm_mux *gsm = tty->disc_data;
2917 unsigned long flags;
2925 spin_lock_irqsave(&gsm->tx_lock, flags);
2926 space = tty_write_room(tty);
2928 ret = tty->ops->write(tty, buf, nr);
2930 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2931 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2937 * gsmld_poll - poll method for N_GSM0710
2938 * @tty: terminal device
2939 * @file: file accessing it
2942 * Called when the line discipline is asked to poll() for data or
2943 * for special events. This code is not serialized with respect to
2944 * other events save open/close.
2946 * This code must be sure never to sleep through a hangup.
2947 * Called without the kernel lock held - fine
2950 static __poll_t gsmld_poll(struct tty_struct *tty, struct file *file,
2954 struct gsm_mux *gsm = tty->disc_data;
2956 poll_wait(file, &tty->read_wait, wait);
2957 poll_wait(file, &tty->write_wait, wait);
2961 if (tty_hung_up_p(file))
2963 if (test_bit(TTY_OTHER_CLOSED, &tty->flags))
2965 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2966 mask |= EPOLLOUT | EPOLLWRNORM;
2970 static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2971 unsigned int cmd, unsigned long arg)
2973 struct gsm_config c;
2974 struct gsm_mux *gsm = tty->disc_data;
2978 case GSMIOC_GETCONF:
2979 gsm_copy_config_values(gsm, &c);
2980 if (copy_to_user((void __user *)arg, &c, sizeof(c)))
2983 case GSMIOC_SETCONF:
2984 if (copy_from_user(&c, (void __user *)arg, sizeof(c)))
2986 return gsm_config(gsm, &c);
2987 case GSMIOC_GETFIRST:
2988 base = mux_num_to_base(gsm);
2989 return put_user(base + 1, (__u32 __user *)arg);
2991 return n_tty_ioctl_helper(tty, file, cmd, arg);
3000 static int gsm_mux_net_open(struct net_device *net)
3002 pr_debug("%s called\n", __func__);
3003 netif_start_queue(net);
3007 static int gsm_mux_net_close(struct net_device *net)
3009 netif_stop_queue(net);
3013 static void dlci_net_free(struct gsm_dlci *dlci)
3019 dlci->adaption = dlci->prev_adaption;
3020 dlci->data = dlci->prev_data;
3021 free_netdev(dlci->net);
3024 static void net_free(struct kref *ref)
3026 struct gsm_mux_net *mux_net;
3027 struct gsm_dlci *dlci;
3029 mux_net = container_of(ref, struct gsm_mux_net, ref);
3030 dlci = mux_net->dlci;
3033 unregister_netdev(dlci->net);
3034 dlci_net_free(dlci);
3038 static inline void muxnet_get(struct gsm_mux_net *mux_net)
3040 kref_get(&mux_net->ref);
3043 static inline void muxnet_put(struct gsm_mux_net *mux_net)
3045 kref_put(&mux_net->ref, net_free);
3048 static netdev_tx_t gsm_mux_net_start_xmit(struct sk_buff *skb,
3049 struct net_device *net)
3051 struct gsm_mux_net *mux_net = netdev_priv(net);
3052 struct gsm_dlci *dlci = mux_net->dlci;
3053 muxnet_get(mux_net);
3055 skb_queue_head(&dlci->skb_list, skb);
3056 net->stats.tx_packets++;
3057 net->stats.tx_bytes += skb->len;
3058 gsm_dlci_data_kick(dlci);
3059 /* And tell the kernel when the last transmit started. */
3060 netif_trans_update(net);
3061 muxnet_put(mux_net);
3062 return NETDEV_TX_OK;
3065 /* called when a packet did not ack after watchdogtimeout */
3066 static void gsm_mux_net_tx_timeout(struct net_device *net, unsigned int txqueue)
3068 /* Tell syslog we are hosed. */
3069 dev_dbg(&net->dev, "Tx timed out.\n");
3071 /* Update statistics */
3072 net->stats.tx_errors++;
3075 static void gsm_mux_rx_netchar(struct gsm_dlci *dlci,
3076 const unsigned char *in_buf, int size)
3078 struct net_device *net = dlci->net;
3079 struct sk_buff *skb;
3080 struct gsm_mux_net *mux_net = netdev_priv(net);
3081 muxnet_get(mux_net);
3083 /* Allocate an sk_buff */
3084 skb = dev_alloc_skb(size + NET_IP_ALIGN);
3086 /* We got no receive buffer. */
3087 net->stats.rx_dropped++;
3088 muxnet_put(mux_net);
3091 skb_reserve(skb, NET_IP_ALIGN);
3092 skb_put_data(skb, in_buf, size);
3095 skb->protocol = htons(ETH_P_IP);
3097 /* Ship it off to the kernel */
3100 /* update out statistics */
3101 net->stats.rx_packets++;
3102 net->stats.rx_bytes += size;
3103 muxnet_put(mux_net);
3107 static void gsm_mux_net_init(struct net_device *net)
3109 static const struct net_device_ops gsm_netdev_ops = {
3110 .ndo_open = gsm_mux_net_open,
3111 .ndo_stop = gsm_mux_net_close,
3112 .ndo_start_xmit = gsm_mux_net_start_xmit,
3113 .ndo_tx_timeout = gsm_mux_net_tx_timeout,
3116 net->netdev_ops = &gsm_netdev_ops;
3118 /* fill in the other fields */
3119 net->watchdog_timeo = GSM_NET_TX_TIMEOUT;
3120 net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
3121 net->type = ARPHRD_NONE;
3122 net->tx_queue_len = 10;
3126 /* caller holds the dlci mutex */
3127 static void gsm_destroy_network(struct gsm_dlci *dlci)
3129 struct gsm_mux_net *mux_net;
3131 pr_debug("destroy network interface\n");
3134 mux_net = netdev_priv(dlci->net);
3135 muxnet_put(mux_net);
3139 /* caller holds the dlci mutex */
3140 static int gsm_create_network(struct gsm_dlci *dlci, struct gsm_netconfig *nc)
3144 struct net_device *net;
3145 struct gsm_mux_net *mux_net;
3147 if (!capable(CAP_NET_ADMIN))
3150 /* Already in a non tty mode */
3151 if (dlci->adaption > 2)
3154 if (nc->protocol != htons(ETH_P_IP))
3155 return -EPROTONOSUPPORT;
3157 if (nc->adaption != 3 && nc->adaption != 4)
3158 return -EPROTONOSUPPORT;
3160 pr_debug("create network interface\n");
3163 if (nc->if_name[0] != '\0')
3164 netname = nc->if_name;
3165 net = alloc_netdev(sizeof(struct gsm_mux_net), netname,
3166 NET_NAME_UNKNOWN, gsm_mux_net_init);
3168 pr_err("alloc_netdev failed\n");
3171 net->mtu = dlci->gsm->mtu;
3173 net->max_mtu = dlci->gsm->mtu;
3174 mux_net = netdev_priv(net);
3175 mux_net->dlci = dlci;
3176 kref_init(&mux_net->ref);
3177 strncpy(nc->if_name, net->name, IFNAMSIZ); /* return net name */
3179 /* reconfigure dlci for network */
3180 dlci->prev_adaption = dlci->adaption;
3181 dlci->prev_data = dlci->data;
3182 dlci->adaption = nc->adaption;
3183 dlci->data = gsm_mux_rx_netchar;
3186 pr_debug("register netdev\n");
3187 retval = register_netdev(net);
3189 pr_err("network register fail %d\n", retval);
3190 dlci_net_free(dlci);
3193 return net->ifindex; /* return network index */
3196 /* Line discipline for real tty */
3197 static struct tty_ldisc_ops tty_ldisc_packet = {
3198 .owner = THIS_MODULE,
3202 .close = gsmld_close,
3203 .flush_buffer = gsmld_flush_buffer,
3205 .write = gsmld_write,
3206 .ioctl = gsmld_ioctl,
3208 .receive_buf = gsmld_receive_buf,
3209 .write_wakeup = gsmld_write_wakeup
3217 * gsm_modem_upd_via_data - send modem bits via convergence layer
3219 * @brk: break signal
3221 * Send an empty frame to signal mobile state changes and to transmit the
3222 * break signal for adaption 2.
3225 static void gsm_modem_upd_via_data(struct gsm_dlci *dlci, u8 brk)
3227 struct gsm_mux *gsm = dlci->gsm;
3228 unsigned long flags;
3230 if (dlci->state != DLCI_OPEN || dlci->adaption != 2)
3233 spin_lock_irqsave(&gsm->tx_lock, flags);
3234 gsm_dlci_modem_output(gsm, dlci, brk);
3235 spin_unlock_irqrestore(&gsm->tx_lock, flags);
3239 * gsm_modem_upd_via_msc - send modem bits via control frame
3241 * @brk: break signal
3244 static int gsm_modem_upd_via_msc(struct gsm_dlci *dlci, u8 brk)
3247 struct gsm_control *ctrl;
3250 if (dlci->gsm->encoding != 0)
3253 modembits[0] = (dlci->addr << 2) | 2 | EA; /* DLCI, Valid, EA */
3255 modembits[1] = (gsm_encode_modem(dlci) << 1) | EA;
3257 modembits[1] = gsm_encode_modem(dlci) << 1;
3258 modembits[2] = (brk << 4) | 2 | EA; /* Length, Break, EA */
3261 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len);
3264 return gsm_control_wait(dlci->gsm, ctrl);
3268 * gsm_modem_update - send modem status line state
3270 * @brk: break signal
3273 static int gsm_modem_update(struct gsm_dlci *dlci, u8 brk)
3275 if (dlci->adaption == 2) {
3276 /* Send convergence layer type 2 empty data frame. */
3277 gsm_modem_upd_via_data(dlci, brk);
3279 } else if (dlci->gsm->encoding == 0) {
3280 /* Send as MSC control message. */
3281 return gsm_modem_upd_via_msc(dlci, brk);
3284 /* Modem status lines are not supported. */
3285 return -EPROTONOSUPPORT;
3288 static int gsm_carrier_raised(struct tty_port *port)
3290 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
3291 struct gsm_mux *gsm = dlci->gsm;
3293 /* Not yet open so no carrier info */
3294 if (dlci->state != DLCI_OPEN)
3300 * Basic mode with control channel in ADM mode may not respond
3301 * to CMD_MSC at all and modem_rx is empty.
3303 if (gsm->encoding == 0 && gsm->dlci[0]->mode == DLCI_MODE_ADM &&
3307 return dlci->modem_rx & TIOCM_CD;
3310 static void gsm_dtr_rts(struct tty_port *port, int onoff)
3312 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
3313 unsigned int modem_tx = dlci->modem_tx;
3315 modem_tx |= TIOCM_DTR | TIOCM_RTS;
3317 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
3318 if (modem_tx != dlci->modem_tx) {
3319 dlci->modem_tx = modem_tx;
3320 gsm_modem_update(dlci, 0);
3324 static const struct tty_port_operations gsm_port_ops = {
3325 .carrier_raised = gsm_carrier_raised,
3326 .dtr_rts = gsm_dtr_rts,
3327 .destruct = gsm_dlci_free,
3330 static int gsmtty_install(struct tty_driver *driver, struct tty_struct *tty)
3332 struct gsm_mux *gsm;
3333 struct gsm_dlci *dlci;
3334 unsigned int line = tty->index;
3335 unsigned int mux = mux_line_to_num(line);
3343 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
3344 if (gsm_mux[mux] == NULL)
3346 if (line == 0 || line > 61) /* 62/63 reserved */
3351 /* If DLCI 0 is not yet fully open return an error.
3352 This is ok from a locking
3353 perspective as we don't have to worry about this
3355 mutex_lock(&gsm->mutex);
3356 if (gsm->dlci[0] && gsm->dlci[0]->state != DLCI_OPEN) {
3357 mutex_unlock(&gsm->mutex);
3360 dlci = gsm->dlci[line];
3363 dlci = gsm_dlci_alloc(gsm, line);
3366 mutex_unlock(&gsm->mutex);
3369 ret = tty_port_install(&dlci->port, driver, tty);
3373 mutex_unlock(&gsm->mutex);
3378 dlci_get(gsm->dlci[0]);
3380 tty->driver_data = dlci;
3381 mutex_unlock(&gsm->mutex);
3386 static int gsmtty_open(struct tty_struct *tty, struct file *filp)
3388 struct gsm_dlci *dlci = tty->driver_data;
3389 struct tty_port *port = &dlci->port;
3390 struct gsm_mux *gsm = dlci->gsm;
3393 tty_port_tty_set(port, tty);
3396 /* We could in theory open and close before we wait - eg if we get
3397 a DM straight back. This is ok as that will have caused a hangup */
3398 tty_port_set_initialized(port, 1);
3399 /* Start sending off SABM messages */
3401 gsm_dlci_begin_open(dlci);
3403 gsm_dlci_set_opening(dlci);
3404 /* And wait for virtual carrier */
3405 return tty_port_block_til_ready(port, tty, filp);
3408 static void gsmtty_close(struct tty_struct *tty, struct file *filp)
3410 struct gsm_dlci *dlci = tty->driver_data;
3414 if (dlci->state == DLCI_CLOSED)
3416 mutex_lock(&dlci->mutex);
3417 gsm_destroy_network(dlci);
3418 mutex_unlock(&dlci->mutex);
3419 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
3421 gsm_dlci_begin_close(dlci);
3422 if (tty_port_initialized(&dlci->port) && C_HUPCL(tty))
3423 tty_port_lower_dtr_rts(&dlci->port);
3424 tty_port_close_end(&dlci->port, tty);
3425 tty_port_tty_set(&dlci->port, NULL);
3429 static void gsmtty_hangup(struct tty_struct *tty)
3431 struct gsm_dlci *dlci = tty->driver_data;
3432 if (dlci->state == DLCI_CLOSED)
3434 tty_port_hangup(&dlci->port);
3435 gsm_dlci_begin_close(dlci);
3438 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
3442 struct gsm_dlci *dlci = tty->driver_data;
3443 if (dlci->state == DLCI_CLOSED)
3445 /* Stuff the bytes into the fifo queue */
3446 sent = kfifo_in_locked(&dlci->fifo, buf, len, &dlci->lock);
3447 /* Need to kick the channel */
3448 gsm_dlci_data_kick(dlci);
3452 static unsigned int gsmtty_write_room(struct tty_struct *tty)
3454 struct gsm_dlci *dlci = tty->driver_data;
3455 if (dlci->state == DLCI_CLOSED)
3457 return kfifo_avail(&dlci->fifo);
3460 static unsigned int gsmtty_chars_in_buffer(struct tty_struct *tty)
3462 struct gsm_dlci *dlci = tty->driver_data;
3463 if (dlci->state == DLCI_CLOSED)
3465 return kfifo_len(&dlci->fifo);
3468 static void gsmtty_flush_buffer(struct tty_struct *tty)
3470 struct gsm_dlci *dlci = tty->driver_data;
3471 unsigned long flags;
3473 if (dlci->state == DLCI_CLOSED)
3475 /* Caution needed: If we implement reliable transport classes
3476 then the data being transmitted can't simply be junked once
3477 it has first hit the stack. Until then we can just blow it
3479 spin_lock_irqsave(&dlci->lock, flags);
3480 kfifo_reset(&dlci->fifo);
3481 spin_unlock_irqrestore(&dlci->lock, flags);
3482 /* Need to unhook this DLCI from the transmit queue logic */
3485 static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
3487 /* The FIFO handles the queue so the kernel will do the right
3488 thing waiting on chars_in_buffer before calling us. No work
3492 static int gsmtty_tiocmget(struct tty_struct *tty)
3494 struct gsm_dlci *dlci = tty->driver_data;
3495 if (dlci->state == DLCI_CLOSED)
3497 return dlci->modem_rx;
3500 static int gsmtty_tiocmset(struct tty_struct *tty,
3501 unsigned int set, unsigned int clear)
3503 struct gsm_dlci *dlci = tty->driver_data;
3504 unsigned int modem_tx = dlci->modem_tx;
3506 if (dlci->state == DLCI_CLOSED)
3511 if (modem_tx != dlci->modem_tx) {
3512 dlci->modem_tx = modem_tx;
3513 return gsm_modem_update(dlci, 0);
3519 static int gsmtty_ioctl(struct tty_struct *tty,
3520 unsigned int cmd, unsigned long arg)
3522 struct gsm_dlci *dlci = tty->driver_data;
3523 struct gsm_netconfig nc;
3526 if (dlci->state == DLCI_CLOSED)
3529 case GSMIOC_ENABLE_NET:
3530 if (copy_from_user(&nc, (void __user *)arg, sizeof(nc)))
3532 nc.if_name[IFNAMSIZ-1] = '\0';
3533 /* return net interface index or error code */
3534 mutex_lock(&dlci->mutex);
3535 index = gsm_create_network(dlci, &nc);
3536 mutex_unlock(&dlci->mutex);
3537 if (copy_to_user((void __user *)arg, &nc, sizeof(nc)))
3540 case GSMIOC_DISABLE_NET:
3541 if (!capable(CAP_NET_ADMIN))
3543 mutex_lock(&dlci->mutex);
3544 gsm_destroy_network(dlci);
3545 mutex_unlock(&dlci->mutex);
3548 return -ENOIOCTLCMD;
3552 static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
3554 struct gsm_dlci *dlci = tty->driver_data;
3555 if (dlci->state == DLCI_CLOSED)
3557 /* For the moment its fixed. In actual fact the speed information
3558 for the virtual channel can be propogated in both directions by
3559 the RPN control message. This however rapidly gets nasty as we
3560 then have to remap modem signals each way according to whether
3561 our virtual cable is null modem etc .. */
3562 tty_termios_copy_hw(&tty->termios, old);
3565 static void gsmtty_throttle(struct tty_struct *tty)
3567 struct gsm_dlci *dlci = tty->driver_data;
3568 if (dlci->state == DLCI_CLOSED)
3571 dlci->modem_tx &= ~TIOCM_RTS;
3572 dlci->throttled = true;
3573 /* Send an MSC with RTS cleared */
3574 gsm_modem_update(dlci, 0);
3577 static void gsmtty_unthrottle(struct tty_struct *tty)
3579 struct gsm_dlci *dlci = tty->driver_data;
3580 if (dlci->state == DLCI_CLOSED)
3583 dlci->modem_tx |= TIOCM_RTS;
3584 dlci->throttled = false;
3585 /* Send an MSC with RTS set */
3586 gsm_modem_update(dlci, 0);
3589 static int gsmtty_break_ctl(struct tty_struct *tty, int state)
3591 struct gsm_dlci *dlci = tty->driver_data;
3592 int encode = 0; /* Off */
3593 if (dlci->state == DLCI_CLOSED)
3596 if (state == -1) /* "On indefinitely" - we can't encode this
3599 else if (state > 0) {
3600 encode = state / 200; /* mS to encoding */
3602 encode = 0x0F; /* Best effort */
3604 return gsm_modem_update(dlci, encode);
3607 static void gsmtty_cleanup(struct tty_struct *tty)
3609 struct gsm_dlci *dlci = tty->driver_data;
3610 struct gsm_mux *gsm = dlci->gsm;
3613 dlci_put(gsm->dlci[0]);
3617 /* Virtual ttys for the demux */
3618 static const struct tty_operations gsmtty_ops = {
3619 .install = gsmtty_install,
3620 .open = gsmtty_open,
3621 .close = gsmtty_close,
3622 .write = gsmtty_write,
3623 .write_room = gsmtty_write_room,
3624 .chars_in_buffer = gsmtty_chars_in_buffer,
3625 .flush_buffer = gsmtty_flush_buffer,
3626 .ioctl = gsmtty_ioctl,
3627 .throttle = gsmtty_throttle,
3628 .unthrottle = gsmtty_unthrottle,
3629 .set_termios = gsmtty_set_termios,
3630 .hangup = gsmtty_hangup,
3631 .wait_until_sent = gsmtty_wait_until_sent,
3632 .tiocmget = gsmtty_tiocmget,
3633 .tiocmset = gsmtty_tiocmset,
3634 .break_ctl = gsmtty_break_ctl,
3635 .cleanup = gsmtty_cleanup,
3640 static int __init gsm_init(void)
3642 /* Fill in our line protocol discipline, and register it */
3643 int status = tty_register_ldisc(&tty_ldisc_packet);
3645 pr_err("n_gsm: can't register line discipline (err = %d)\n",
3650 gsm_tty_driver = tty_alloc_driver(256, TTY_DRIVER_REAL_RAW |
3651 TTY_DRIVER_DYNAMIC_DEV | TTY_DRIVER_HARDWARE_BREAK);
3652 if (IS_ERR(gsm_tty_driver)) {
3653 pr_err("gsm_init: tty allocation failed.\n");
3654 status = PTR_ERR(gsm_tty_driver);
3655 goto err_unreg_ldisc;
3657 gsm_tty_driver->driver_name = "gsmtty";
3658 gsm_tty_driver->name = "gsmtty";
3659 gsm_tty_driver->major = 0; /* Dynamic */
3660 gsm_tty_driver->minor_start = 0;
3661 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
3662 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
3663 gsm_tty_driver->init_termios = tty_std_termios;
3665 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
3666 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
3668 if (tty_register_driver(gsm_tty_driver)) {
3669 pr_err("gsm_init: tty registration failed.\n");
3671 goto err_put_driver;
3673 pr_debug("gsm_init: loaded as %d,%d.\n",
3674 gsm_tty_driver->major, gsm_tty_driver->minor_start);
3677 tty_driver_kref_put(gsm_tty_driver);
3679 tty_unregister_ldisc(&tty_ldisc_packet);
3683 static void __exit gsm_exit(void)
3685 tty_unregister_ldisc(&tty_ldisc_packet);
3686 tty_unregister_driver(gsm_tty_driver);
3687 tty_driver_kref_put(gsm_tty_driver);
3690 module_init(gsm_init);
3691 module_exit(gsm_exit);
3694 MODULE_LICENSE("GPL");
3695 MODULE_ALIAS_LDISC(N_GSM0710);