2 * n_gsm.c GSM 0710 tty multiplexor
3 * Copyright (c) 2009/10 Intel Corporation
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 * * THIS IS A DEVELOPMENT SNAPSHOT IT IS NOT A FINAL RELEASE *
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 ?
25 * Improve the tx engine
26 * Resolve tx side locking by adding a queue_head and routing
27 * all control traffic via it
28 * General tidy/document
29 * Review the locking/move to refcounts more (mux now moved to an
30 * alloc/free model ready)
31 * Use newest tty open/close port helpers and install hooks
32 * What to do about power functions ?
33 * Termios setting and negotiation
34 * Do we need a 'which mux are you' ioctl to correlate mux and tty sets
38 #include <linux/types.h>
39 #include <linux/major.h>
40 #include <linux/errno.h>
41 #include <linux/signal.h>
42 #include <linux/fcntl.h>
43 #include <linux/sched.h>
44 #include <linux/interrupt.h>
45 #include <linux/tty.h>
46 #include <linux/ctype.h>
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>
64 module_param(debug, int, 0600);
70 /* Use long timers for testing at low speed with debug on */
77 * Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte
78 * limits so this is plenty
84 * Each block of data we have queued to go out is in the form of
85 * a gsm_msg which holds everything we need in a link layer independent
91 u8 addr; /* DLCI address + flags */
92 u8 ctrl; /* Control byte + flags */
93 unsigned int len; /* Length of data block (can be zero) */
94 unsigned char *data; /* Points into buffer but not at the start */
95 unsigned char buffer[0];
99 * Each active data link has a gsm_dlci structure associated which ties
100 * the link layer to an optional tty (if the tty side is open). To avoid
101 * complexity right now these are only ever freed up when the mux is
104 * At the moment we don't free DLCI objects until the mux is torn down
105 * this avoid object life time issues but might be worth review later.
112 #define DLCI_CLOSED 0
113 #define DLCI_OPENING 1 /* Sending SABM not seen UA */
114 #define DLCI_OPEN 2 /* SABM/UA complete */
115 #define DLCI_CLOSING 3 /* Sending DISC not seen UA/DM */
118 spinlock_t lock; /* Protects the internal state */
119 struct timer_list t1; /* Retransmit timer for SABM and UA */
121 /* Uplink tty if active */
122 struct tty_port port; /* The tty bound to this DLCI if there is one */
123 struct kfifo *fifo; /* Queue fifo for the DLCI */
124 struct kfifo _fifo; /* For new fifo API porting only */
125 int adaption; /* Adaption layer in use */
126 u32 modem_rx; /* Our incoming virtual modem lines */
127 u32 modem_tx; /* Our outgoing modem lines */
128 int dead; /* Refuse re-open */
130 int throttled; /* Private copy of throttle state */
131 int constipated; /* Throttle status for outgoing */
133 struct sk_buff *skb; /* Frame being sent */
134 struct sk_buff_head skb_list; /* Queued frames */
135 /* Data handling callback */
136 void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
139 /* DLCI 0, 62/63 are special or reseved see gsmtty_open */
144 * DLCI 0 is used to pass control blocks out of band of the data
145 * flow (and with a higher link priority). One command can be outstanding
146 * at a time and we use this structure to manage them. They are created
147 * and destroyed by the user context, and updated by the receive paths
152 u8 cmd; /* Command we are issuing */
153 u8 *data; /* Data for the command in case we retransmit */
154 int len; /* Length of block for retransmission */
155 int done; /* Done flag */
156 int error; /* Error if any */
160 * Each GSM mux we have is represented by this structure. If we are
161 * operating as an ldisc then we use this structure as our ldisc
162 * state. We need to sort out lifetimes and locking with respect
163 * to the gsm mux array. For now we don't free DLCI objects that
164 * have been instantiated until the mux itself is terminated.
166 * To consider further: tty open versus mux shutdown.
170 struct tty_struct *tty; /* The tty our ldisc is bound to */
173 /* Events on the GSM channel */
174 wait_queue_head_t event;
176 /* Bits for GSM mode decoding */
183 #define GSM_ADDRESS 2
184 #define GSM_CONTROL 3
188 #define GSM_OVERRUN 7
193 unsigned int address;
200 u8 *txframe; /* TX framing buffer */
202 /* Methods for the receiver side */
203 void (*receive)(struct gsm_mux *gsm, u8 ch);
204 void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
205 /* And transmit side */
206 int (*output)(struct gsm_mux *mux, u8 *data, int len);
211 int initiator; /* Did we initiate connection */
212 int dead; /* Has the mux been shut down */
213 struct gsm_dlci *dlci[NUM_DLCI];
214 int constipated; /* Asked by remote to shut up */
217 unsigned int tx_bytes; /* TX data outstanding */
218 #define TX_THRESH_HI 8192
219 #define TX_THRESH_LO 2048
220 struct gsm_msg *tx_head; /* Pending data packets */
221 struct gsm_msg *tx_tail;
223 /* Control messages */
224 struct timer_list t2_timer; /* Retransmit timer for commands */
225 int cretries; /* Command retry counter */
226 struct gsm_control *pending_cmd;/* Our current pending command */
227 spinlock_t control_lock; /* Protects the pending command */
230 int adaption; /* 1 or 2 supported */
231 u8 ftype; /* UI or UIH */
232 int t1, t2; /* Timers in 1/100th of a sec */
233 int n2; /* Retry count */
235 /* Statistics (not currently exposed) */
236 unsigned long bad_fcs;
237 unsigned long malformed;
238 unsigned long io_error;
239 unsigned long bad_size;
240 unsigned long unsupported;
245 * Mux objects - needed so that we can translate a tty index into the
246 * relevant mux and DLCI.
249 #define MAX_MUX 4 /* 256 minors */
250 static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */
251 static spinlock_t gsm_mux_lock;
254 * This section of the driver logic implements the GSM encodings
255 * both the basic and the 'advanced'. Reliable transport is not
263 /* I is special: the rest are ..*/
274 /* Channel commands */
276 #define CMD_TEST 0x11
279 #define CMD_FCOFF 0x31
282 #define CMD_FCON 0x51
287 /* Virtual modem bits */
294 #define GSM0_SOF 0xF9
295 #define GSM1_SOF 0x7E
296 #define GSM1_ESCAPE 0x7D
297 #define GSM1_ESCAPE_BITS 0x20
301 static const struct tty_port_operations gsm_port_ops;
304 * CRC table for GSM 0710
307 static const u8 gsm_fcs8[256] = {
308 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
309 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
310 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
311 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
312 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
313 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
314 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
315 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
316 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
317 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
318 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
319 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
320 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
321 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
322 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
323 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
324 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
325 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
326 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
327 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
328 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
329 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
330 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
331 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
332 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
333 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
334 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
335 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
336 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
337 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
338 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
339 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
342 #define INIT_FCS 0xFF
343 #define GOOD_FCS 0xCF
346 * gsm_fcs_add - update FCS
350 * Update the FCS to include c. Uses the algorithm in the specification
354 static inline u8 gsm_fcs_add(u8 fcs, u8 c)
356 return gsm_fcs8[fcs ^ c];
360 * gsm_fcs_add_block - update FCS for a block
363 * @len: length of buffer
365 * Update the FCS to include c. Uses the algorithm in the specification
369 static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
372 fcs = gsm_fcs8[fcs ^ *c++];
377 * gsm_read_ea - read a byte into an EA
378 * @val: variable holding value
379 * c: byte going into the EA
381 * Processes one byte of an EA. Updates the passed variable
382 * and returns 1 if the EA is now completely read
385 static int gsm_read_ea(unsigned int *val, u8 c)
387 /* Add the next 7 bits into the value */
390 /* Was this the last byte of the EA 1 = yes*/
395 * gsm_encode_modem - encode modem data bits
396 * @dlci: DLCI to encode from
398 * Returns the correct GSM encoded modem status bits (6 bit field) for
399 * the current status of the DLCI and attached tty object
402 static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
405 /* FC is true flow control not modem bits */
408 if (dlci->modem_tx & TIOCM_DTR)
409 modembits |= MDM_RTC;
410 if (dlci->modem_tx & TIOCM_RTS)
411 modembits |= MDM_RTR;
412 if (dlci->modem_tx & TIOCM_RI)
414 if (dlci->modem_tx & TIOCM_CD)
420 * gsm_print_packet - display a frame for debug
421 * @hdr: header to print before decode
422 * @addr: address EA from the frame
423 * @cr: C/R bit from the frame
424 * @control: control including PF bit
425 * @data: following data bytes
426 * @dlen: length of data
428 * Displays a packet in human readable format for debugging purposes. The
429 * style is based on amateur radio LAP-B dump display.
432 static void gsm_print_packet(const char *hdr, int addr, int cr,
433 u8 control, const u8 *data, int dlen)
438 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
440 switch (control & ~PF) {
460 if (!(control & 0x01)) {
461 pr_cont("I N(S)%d N(R)%d",
462 (control & 0x0E) >> 1, (control & 0xE) >> 5);
463 } else switch (control & 0x0F) {
465 pr_cont("RR(%d)", (control & 0xE0) >> 5);
468 pr_cont("RNR(%d)", (control & 0xE0) >> 5);
471 pr_cont("REJ(%d)", (control & 0xE0) >> 5);
474 pr_cont("[%02X]", control);
490 pr_cont("%02X ", *data++);
499 * Link level transmission side
503 * gsm_stuff_packet - bytestuff a packet
506 * @len: length of input
508 * Expand a buffer by bytestuffing it. The worst case size change
509 * is doubling and the caller is responsible for handing out
510 * suitable sized buffers.
513 static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
517 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
518 || *input == XON || *input == XOFF) {
519 *output++ = GSM1_ESCAPE;
520 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
523 *output++ = *input++;
530 * gsm_send - send a control frame
532 * @addr: address for control frame
533 * @cr: command/response bit
534 * @control: control byte including PF bit
536 * Format up and transmit a control frame. These do not go via the
537 * queueing logic as they should be transmitted ahead of data when
540 * FIXME: Lock versus data TX path
543 static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
549 switch (gsm->encoding) {
552 cbuf[1] = (addr << 2) | (cr << 1) | EA;
554 cbuf[3] = EA; /* Length of data = 0 */
555 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
561 /* Control frame + packing (but not frame stuffing) in mode 1 */
562 ibuf[0] = (addr << 2) | (cr << 1) | EA;
564 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
565 /* Stuffing may double the size worst case */
566 len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
567 /* Now add the SOF markers */
569 cbuf[len + 1] = GSM1_SOF;
570 /* FIXME: we can omit the lead one in many cases */
577 gsm->output(gsm, cbuf, len);
578 gsm_print_packet("-->", addr, cr, control, NULL, 0);
582 * gsm_response - send a control response
584 * @addr: address for control frame
585 * @control: control byte including PF bit
587 * Format up and transmit a link level response frame.
590 static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
592 gsm_send(gsm, addr, 0, control);
596 * gsm_command - send a control command
598 * @addr: address for control frame
599 * @control: control byte including PF bit
601 * Format up and transmit a link level command frame.
604 static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
606 gsm_send(gsm, addr, 1, control);
609 /* Data transmission */
611 #define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
614 * gsm_data_alloc - allocate data frame
616 * @addr: DLCI address
617 * @len: length excluding header and FCS
618 * @ctrl: control byte
620 * Allocate a new data buffer for sending frames with data. Space is left
621 * at the front for header bytes but that is treated as an implementation
622 * detail and not for the high level code to use
625 static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
628 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
632 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */
641 * gsm_data_kick - poke the queue
644 * The tty device has called us to indicate that room has appeared in
645 * the transmit queue. Ram more data into the pipe if we have any
647 * FIXME: lock against link layer control transmissions
650 static void gsm_data_kick(struct gsm_mux *gsm)
652 struct gsm_msg *msg = gsm->tx_head;
656 /* FIXME: We need to apply this solely to data messages */
657 if (gsm->constipated)
660 while (gsm->tx_head != NULL) {
662 if (gsm->encoding != 0) {
663 gsm->txframe[0] = GSM1_SOF;
664 len = gsm_stuff_frame(msg->data,
665 gsm->txframe + 1, msg->len);
666 gsm->txframe[len + 1] = GSM1_SOF;
669 gsm->txframe[0] = GSM0_SOF;
670 memcpy(gsm->txframe + 1 , msg->data, msg->len);
671 gsm->txframe[msg->len + 1] = GSM0_SOF;
676 print_hex_dump_bytes("gsm_data_kick: ",
680 if (gsm->output(gsm, gsm->txframe + skip_sof,
683 /* FIXME: Can eliminate one SOF in many more cases */
684 gsm->tx_head = msg->next;
685 if (gsm->tx_head == NULL)
687 gsm->tx_bytes -= msg->len;
689 /* For a burst of frames skip the extra SOF within the
696 * __gsm_data_queue - queue a UI or UIH frame
697 * @dlci: DLCI sending the data
698 * @msg: message queued
700 * Add data to the transmit queue and try and get stuff moving
701 * out of the mux tty if not already doing so. The Caller must hold
705 static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
707 struct gsm_mux *gsm = dlci->gsm;
709 u8 *fcs = dp + msg->len;
711 /* Fill in the header */
712 if (gsm->encoding == 0) {
714 *--dp = (msg->len << 1) | EA;
716 *--dp = (msg->len >> 7); /* bits 7 - 15 */
717 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */
723 *--dp = (msg->addr << 2) | 2 | EA;
725 *--dp = (msg->addr << 2) | EA;
726 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
727 /* Ugly protocol layering violation */
728 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
729 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
732 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
733 msg->data, msg->len);
735 /* Move the header back and adjust the length, also allow for the FCS
736 now tacked on the end */
737 msg->len += (msg->data - dp) + 1;
740 /* Add to the actual output queue */
742 gsm->tx_tail->next = msg;
746 gsm->tx_bytes += msg->len;
751 * gsm_data_queue - queue a UI or UIH frame
752 * @dlci: DLCI sending the data
753 * @msg: message queued
755 * Add data to the transmit queue and try and get stuff moving
756 * out of the mux tty if not already doing so. Take the
757 * the gsm tx lock and dlci lock.
760 static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
763 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
764 __gsm_data_queue(dlci, msg);
765 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
769 * gsm_dlci_data_output - try and push data out of a DLCI
771 * @dlci: the DLCI to pull data from
773 * Pull data from a DLCI and send it into the transmit queue if there
774 * is data. Keep to the MRU of the mux. This path handles the usual tty
775 * interface which is a byte stream with optional modem data.
777 * Caller must hold the tx_lock of the mux.
780 static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
785 int h = dlci->adaption - 1;
787 len = kfifo_len(dlci->fifo);
791 /* MTU/MRU count only the data bits */
797 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
798 /* FIXME: need a timer or something to kick this so it can't
799 get stuck with no work outstanding and no buffer free */
803 switch (dlci->adaption) {
804 case 1: /* Unstructured */
806 case 2: /* Unstructed with modem bits. Always one byte as we never
807 send inline break data */
808 *dp += gsm_encode_modem(dlci);
812 WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
813 __gsm_data_queue(dlci, msg);
814 /* Bytes of data we used up */
819 * gsm_dlci_data_output_framed - try and push data out of a DLCI
821 * @dlci: the DLCI to pull data from
823 * Pull data from a DLCI and send it into the transmit queue if there
824 * is data. Keep to the MRU of the mux. This path handles framed data
825 * queued as skbuffs to the DLCI.
827 * Caller must hold the tx_lock of the mux.
830 static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
831 struct gsm_dlci *dlci)
836 int last = 0, first = 0;
839 /* One byte per frame is used for B/F flags */
840 if (dlci->adaption == 4)
843 /* dlci->skb is locked by tx_lock */
844 if (dlci->skb == NULL) {
845 dlci->skb = skb_dequeue_tail(&dlci->skb_list);
846 if (dlci->skb == NULL)
850 len = dlci->skb->len + overhead;
852 /* MTU/MRU count only the data bits */
853 if (len > gsm->mtu) {
854 if (dlci->adaption == 3) {
855 /* Over long frame, bin it */
856 kfree_skb(dlci->skb);
864 size = len + overhead;
865 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
867 /* FIXME: need a timer or something to kick this so it can't
868 get stuck with no work outstanding and no buffer free */
870 skb_queue_tail(&dlci->skb_list, dlci->skb);
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 */
881 memcpy(dp, dlci->skb->data, len);
882 skb_pull(dlci->skb, len);
883 __gsm_data_queue(dlci, msg);
890 * gsm_dlci_data_sweep - look for data to send
893 * Sweep the GSM mux channels in priority order looking for ones with
894 * data to send. We could do with optimising this scan a bit. We aim
895 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
896 * TX_THRESH_LO we get called again
898 * FIXME: We should round robin between groups and in theory you can
899 * renegotiate DLCI priorities with optional stuff. Needs optimising.
902 static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
905 /* Priority ordering: We should do priority with RR of the groups */
908 while (i < NUM_DLCI) {
909 struct gsm_dlci *dlci;
911 if (gsm->tx_bytes > TX_THRESH_HI)
914 if (dlci == NULL || dlci->constipated) {
918 if (dlci->adaption < 3)
919 len = gsm_dlci_data_output(gsm, dlci);
921 len = gsm_dlci_data_output_framed(gsm, dlci);
924 /* DLCI empty - try the next */
931 * gsm_dlci_data_kick - transmit if possible
932 * @dlci: DLCI to kick
934 * Transmit data from this DLCI if the queue is empty. We can't rely on
935 * a tty wakeup except when we filled the pipe so we need to fire off
936 * new data ourselves in other cases.
939 static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
943 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
944 /* If we have nothing running then we need to fire up */
945 if (dlci->gsm->tx_bytes == 0)
946 gsm_dlci_data_output(dlci->gsm, dlci);
947 else if (dlci->gsm->tx_bytes < TX_THRESH_LO)
948 gsm_dlci_data_sweep(dlci->gsm);
949 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
953 * Control message processing
958 * gsm_control_reply - send a response frame to a control
960 * @cmd: the command to use
961 * @data: data to follow encoded info
962 * @dlen: length of data
964 * Encode up and queue a UI/UIH frame containing our response.
967 static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
971 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
974 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */
975 msg->data[1] = (dlen << 1) | EA;
976 memcpy(msg->data + 2, data, dlen);
977 gsm_data_queue(gsm->dlci[0], msg);
981 * gsm_process_modem - process received modem status
982 * @tty: virtual tty bound to the DLCI
983 * @dlci: DLCI to affect
984 * @modem: modem bits (full EA)
986 * Used when a modem control message or line state inline in adaption
987 * layer 2 is processed. Sort out the local modem state and throttles
990 static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
996 /* The modem status command can either contain one octet (v.24 signals)
997 or two octets (v.24 signals + break signals). The length field will
998 either be 2 or 3 respectively. This is specified in section
999 5.4.6.3.7 of the 27.010 mux spec. */
1002 modem = modem & 0x7f;
1005 modem = (modem >> 7) & 0x7f;
1008 /* Flow control/ready to communicate */
1009 if (modem & MDM_FC) {
1010 /* Need to throttle our output on this device */
1011 dlci->constipated = 1;
1013 if (modem & MDM_RTC) {
1014 mlines |= TIOCM_DSR | TIOCM_DTR;
1015 dlci->constipated = 0;
1016 gsm_dlci_data_kick(dlci);
1018 /* Map modem bits */
1019 if (modem & MDM_RTR)
1020 mlines |= TIOCM_RTS | TIOCM_CTS;
1026 /* Carrier drop -> hangup */
1028 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1029 if (!(tty->termios->c_cflag & CLOCAL))
1032 tty_insert_flip_char(tty, 0, TTY_BREAK);
1034 dlci->modem_rx = mlines;
1038 * gsm_control_modem - modem status received
1040 * @data: data following command
1041 * @clen: command length
1043 * We have received a modem status control message. This is used by
1044 * the GSM mux protocol to pass virtual modem line status and optionally
1045 * to indicate break signals. Unpack it, convert to Linux representation
1046 * and if need be stuff a break message down the tty.
1049 static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1051 unsigned int addr = 0;
1052 unsigned int modem = 0;
1053 struct gsm_dlci *dlci;
1056 struct tty_struct *tty;
1058 while (gsm_read_ea(&addr, *dp++) == 0) {
1063 /* Must be at least one byte following the EA */
1069 /* Closed port, or invalid ? */
1070 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1072 dlci = gsm->dlci[addr];
1074 while (gsm_read_ea(&modem, *dp++) == 0) {
1079 tty = tty_port_tty_get(&dlci->port);
1080 gsm_process_modem(tty, dlci, modem, clen);
1085 gsm_control_reply(gsm, CMD_MSC, data, clen);
1089 * gsm_control_rls - remote line status
1092 * @clen: data length
1094 * The modem sends us a two byte message on the control channel whenever
1095 * it wishes to send us an error state from the virtual link. Stuff
1096 * this into the uplink tty if present
1099 static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1101 struct tty_struct *tty;
1102 unsigned int addr = 0 ;
1107 while (gsm_read_ea(&addr, *dp++) == 0) {
1112 /* Must be at least one byte following ea */
1117 /* Closed port, or invalid ? */
1118 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1122 if ((bits & 1) == 0)
1124 /* See if we have an uplink tty */
1125 tty = tty_port_tty_get(&gsm->dlci[addr]->port);
1129 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1131 tty_insert_flip_char(tty, 0, TTY_PARITY);
1133 tty_insert_flip_char(tty, 0, TTY_FRAME);
1134 tty_flip_buffer_push(tty);
1137 gsm_control_reply(gsm, CMD_RLS, data, clen);
1140 static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1143 * gsm_control_message - DLCI 0 control processing
1145 * @command: the command EA
1146 * @data: data beyond the command/length EAs
1149 * Input processor for control messages from the other end of the link.
1150 * Processes the incoming request and queues a response frame or an
1151 * NSC response if not supported
1154 static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1158 unsigned long flags;
1162 struct gsm_dlci *dlci = gsm->dlci[0];
1163 /* Modem wishes to close down */
1167 gsm_dlci_begin_close(dlci);
1172 /* Modem wishes to test, reply with the data */
1173 gsm_control_reply(gsm, CMD_TEST, data, clen);
1176 /* Modem wants us to STFU */
1177 gsm->constipated = 1;
1178 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1181 /* Modem can accept data again */
1182 gsm->constipated = 0;
1183 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1184 /* Kick the link in case it is idling */
1185 spin_lock_irqsave(&gsm->tx_lock, flags);
1187 spin_unlock_irqrestore(&gsm->tx_lock, flags);
1190 /* Out of band modem line change indicator for a DLCI */
1191 gsm_control_modem(gsm, data, clen);
1194 /* Out of band error reception for a DLCI */
1195 gsm_control_rls(gsm, data, clen);
1198 /* Modem wishes to enter power saving state */
1199 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1201 /* Optional unsupported commands */
1202 case CMD_PN: /* Parameter negotiation */
1203 case CMD_RPN: /* Remote port negotiation */
1204 case CMD_SNC: /* Service negotiation command */
1206 /* Reply to bad commands with an NSC */
1208 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1214 * gsm_control_response - process a response to our control
1216 * @command: the command (response) EA
1217 * @data: data beyond the command/length EA
1220 * Process a response to an outstanding command. We only allow a single
1221 * control message in flight so this is fairly easy. All the clean up
1222 * is done by the caller, we just update the fields, flag it as done
1226 static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1229 struct gsm_control *ctrl;
1230 unsigned long flags;
1232 spin_lock_irqsave(&gsm->control_lock, flags);
1234 ctrl = gsm->pending_cmd;
1235 /* Does the reply match our command */
1237 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1238 /* Our command was replied to, kill the retry timer */
1239 del_timer(&gsm->t2_timer);
1240 gsm->pending_cmd = NULL;
1241 /* Rejected by the other end */
1242 if (command == CMD_NSC)
1243 ctrl->error = -EOPNOTSUPP;
1245 wake_up(&gsm->event);
1247 spin_unlock_irqrestore(&gsm->control_lock, flags);
1251 * gsm_control_transmit - send control packet
1253 * @ctrl: frame to send
1255 * Send out a pending control command (called under control lock)
1258 static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1260 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype);
1263 msg->data[0] = (ctrl->cmd << 1) | 2 | EA; /* command */
1264 memcpy(msg->data + 1, ctrl->data, ctrl->len);
1265 gsm_data_queue(gsm->dlci[0], msg);
1269 * gsm_control_retransmit - retransmit a control frame
1270 * @data: pointer to our gsm object
1272 * Called off the T2 timer expiry in order to retransmit control frames
1273 * that have been lost in the system somewhere. The control_lock protects
1274 * us from colliding with another sender or a receive completion event.
1275 * In that situation the timer may still occur in a small window but
1276 * gsm->pending_cmd will be NULL and we just let the timer expire.
1279 static void gsm_control_retransmit(unsigned long data)
1281 struct gsm_mux *gsm = (struct gsm_mux *)data;
1282 struct gsm_control *ctrl;
1283 unsigned long flags;
1284 spin_lock_irqsave(&gsm->control_lock, flags);
1285 ctrl = gsm->pending_cmd;
1288 if (gsm->cretries == 0) {
1289 gsm->pending_cmd = NULL;
1290 ctrl->error = -ETIMEDOUT;
1292 spin_unlock_irqrestore(&gsm->control_lock, flags);
1293 wake_up(&gsm->event);
1296 gsm_control_transmit(gsm, ctrl);
1297 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1299 spin_unlock_irqrestore(&gsm->control_lock, flags);
1303 * gsm_control_send - send a control frame on DLCI 0
1304 * @gsm: the GSM channel
1305 * @command: command to send including CR bit
1306 * @data: bytes of data (must be kmalloced)
1307 * @len: length of the block to send
1309 * Queue and dispatch a control command. Only one command can be
1310 * active at a time. In theory more can be outstanding but the matching
1311 * gets really complicated so for now stick to one outstanding.
1314 static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1315 unsigned int command, u8 *data, int clen)
1317 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1319 unsigned long flags;
1323 wait_event(gsm->event, gsm->pending_cmd == NULL);
1324 spin_lock_irqsave(&gsm->control_lock, flags);
1325 if (gsm->pending_cmd != NULL) {
1326 spin_unlock_irqrestore(&gsm->control_lock, flags);
1329 ctrl->cmd = command;
1332 gsm->pending_cmd = ctrl;
1333 gsm->cretries = gsm->n2;
1334 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1335 gsm_control_transmit(gsm, ctrl);
1336 spin_unlock_irqrestore(&gsm->control_lock, flags);
1341 * gsm_control_wait - wait for a control to finish
1343 * @control: control we are waiting on
1345 * Waits for the control to complete or time out. Frees any used
1346 * resources and returns 0 for success, or an error if the remote
1347 * rejected or ignored the request.
1350 static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1353 wait_event(gsm->event, control->done == 1);
1354 err = control->error;
1361 * DLCI level handling: Needs krefs
1365 * State transitions and timers
1369 * gsm_dlci_close - a DLCI has closed
1370 * @dlci: DLCI that closed
1372 * Perform processing when moving a DLCI into closed state. If there
1373 * is an attached tty this is hung up
1376 static void gsm_dlci_close(struct gsm_dlci *dlci)
1378 del_timer(&dlci->t1);
1380 pr_debug("DLCI %d goes closed.\n", dlci->addr);
1381 dlci->state = DLCI_CLOSED;
1382 if (dlci->addr != 0) {
1383 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1388 kfifo_reset(dlci->fifo);
1390 dlci->gsm->dead = 1;
1391 wake_up(&dlci->gsm->event);
1392 /* A DLCI 0 close is a MUX termination so we need to kick that
1393 back to userspace somehow */
1397 * gsm_dlci_open - a DLCI has opened
1398 * @dlci: DLCI that opened
1400 * Perform processing when moving a DLCI into open state.
1403 static void gsm_dlci_open(struct gsm_dlci *dlci)
1405 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1407 del_timer(&dlci->t1);
1408 /* This will let a tty open continue */
1409 dlci->state = DLCI_OPEN;
1411 pr_debug("DLCI %d goes open.\n", dlci->addr);
1412 wake_up(&dlci->gsm->event);
1416 * gsm_dlci_t1 - T1 timer expiry
1417 * @dlci: DLCI that opened
1419 * The T1 timer handles retransmits of control frames (essentially of
1420 * SABM and DISC). We resend the command until the retry count runs out
1421 * in which case an opening port goes back to closed and a closing port
1422 * is simply put into closed state (any further frames from the other
1423 * end will get a DM response)
1426 static void gsm_dlci_t1(unsigned long data)
1428 struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1429 struct gsm_mux *gsm = dlci->gsm;
1431 switch (dlci->state) {
1434 if (dlci->retries) {
1435 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1436 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1438 gsm_dlci_close(dlci);
1442 if (dlci->retries) {
1443 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1444 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1446 gsm_dlci_close(dlci);
1452 * gsm_dlci_begin_open - start channel open procedure
1453 * @dlci: DLCI to open
1455 * Commence opening a DLCI from the Linux side. We issue SABM messages
1456 * to the modem which should then reply with a UA, at which point we
1457 * will move into open state. Opening is done asynchronously with retry
1458 * running off timers and the responses.
1461 static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1463 struct gsm_mux *gsm = dlci->gsm;
1464 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1466 dlci->retries = gsm->n2;
1467 dlci->state = DLCI_OPENING;
1468 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1469 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1473 * gsm_dlci_begin_close - start channel open procedure
1474 * @dlci: DLCI to open
1476 * Commence closing a DLCI from the Linux side. We issue DISC messages
1477 * to the modem which should then reply with a UA, at which point we
1478 * will move into closed state. Closing is done asynchronously with retry
1479 * off timers. We may also receive a DM reply from the other end which
1480 * indicates the channel was already closed.
1483 static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1485 struct gsm_mux *gsm = dlci->gsm;
1486 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1488 dlci->retries = gsm->n2;
1489 dlci->state = DLCI_CLOSING;
1490 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1491 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1495 * gsm_dlci_data - data arrived
1497 * @data: block of bytes received
1498 * @len: length of received block
1500 * A UI or UIH frame has arrived which contains data for a channel
1501 * other than the control channel. If the relevant virtual tty is
1502 * open we shovel the bits down it, if not we drop them.
1505 static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int clen)
1508 struct tty_port *port = &dlci->port;
1509 struct tty_struct *tty = tty_port_tty_get(port);
1510 unsigned int modem = 0;
1514 pr_debug("%d bytes for tty %p\n", len, tty);
1516 switch (dlci->adaption) {
1517 /* Unsupported types */
1518 /* Packetised interruptible data */
1521 /* Packetised uininterruptible voice/data */
1524 /* Asynchronous serial with line state in each frame */
1526 while (gsm_read_ea(&modem, *data++) == 0) {
1531 gsm_process_modem(tty, dlci, modem, clen);
1532 /* Line state will go via DLCI 0 controls only */
1535 tty_insert_flip_string(tty, data, len);
1536 tty_flip_buffer_push(tty);
1543 * gsm_dlci_control - data arrived on control channel
1545 * @data: block of bytes received
1546 * @len: length of received block
1548 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1549 * control channel. This should contain a command EA followed by
1550 * control data bytes. The command EA contains a command/response bit
1551 * and we divide up the work accordingly.
1554 static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1556 /* See what command is involved */
1557 unsigned int command = 0;
1559 if (gsm_read_ea(&command, *data++) == 1) {
1562 /* FIXME: this is properly an EA */
1564 /* Malformed command ? */
1568 gsm_control_message(dlci->gsm, command,
1571 gsm_control_response(dlci->gsm, command,
1579 * Allocate/Free DLCI channels
1583 * gsm_dlci_alloc - allocate a DLCI
1585 * @addr: address of the DLCI
1587 * Allocate and install a new DLCI object into the GSM mux.
1589 * FIXME: review locking races
1592 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1594 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1597 spin_lock_init(&dlci->lock);
1598 dlci->fifo = &dlci->_fifo;
1599 if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1604 skb_queue_head_init(&dlci->skb_list);
1605 init_timer(&dlci->t1);
1606 dlci->t1.function = gsm_dlci_t1;
1607 dlci->t1.data = (unsigned long)dlci;
1608 tty_port_init(&dlci->port);
1609 dlci->port.ops = &gsm_port_ops;
1612 dlci->adaption = gsm->adaption;
1613 dlci->state = DLCI_CLOSED;
1615 dlci->data = gsm_dlci_data;
1617 dlci->data = gsm_dlci_command;
1618 gsm->dlci[addr] = dlci;
1623 * gsm_dlci_free - release DLCI
1624 * @dlci: DLCI to destroy
1626 * Free up a DLCI. Currently to keep the lifetime rules sane we only
1627 * clean up DLCI objects when the MUX closes rather than as the port
1628 * is closed down on both the tty and mux levels.
1632 static void gsm_dlci_free(struct gsm_dlci *dlci)
1634 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1639 del_timer_sync(&dlci->t1);
1640 dlci->gsm->dlci[dlci->addr] = NULL;
1641 kfifo_free(dlci->fifo);
1646 * LAPBish link layer logic
1650 * gsm_queue - a GSM frame is ready to process
1651 * @gsm: pointer to our gsm mux
1653 * At this point in time a frame has arrived and been demangled from
1654 * the line encoding. All the differences between the encodings have
1655 * been handled below us and the frame is unpacked into the structures.
1656 * The fcs holds the header FCS but any data FCS must be added here.
1659 static void gsm_queue(struct gsm_mux *gsm)
1661 struct gsm_dlci *dlci;
1664 /* We have to sneak a look at the packet body to do the FCS.
1665 A somewhat layering violation in the spec */
1667 if ((gsm->control & ~PF) == UI)
1668 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1669 if (gsm->encoding == 0){
1670 /* WARNING: gsm->received_fcs is used for gsm->encoding = 0 only.
1671 In this case it contain the last piece of data
1672 required to generate final CRC */
1673 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1675 if (gsm->fcs != GOOD_FCS) {
1678 pr_debug("BAD FCS %02x\n", gsm->fcs);
1681 address = gsm->address >> 1;
1682 if (address >= NUM_DLCI)
1685 cr = gsm->address & 1; /* C/R bit */
1687 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1689 cr ^= 1 - gsm->initiator; /* Flip so 1 always means command */
1690 dlci = gsm->dlci[address];
1692 switch (gsm->control) {
1697 dlci = gsm_dlci_alloc(gsm, address);
1701 gsm_response(gsm, address, DM);
1703 gsm_response(gsm, address, UA);
1704 gsm_dlci_open(dlci);
1710 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1711 gsm_response(gsm, address, DM);
1714 /* Real close complete */
1715 gsm_response(gsm, address, UA);
1716 gsm_dlci_close(dlci);
1720 if (cr == 0 || dlci == NULL)
1722 switch (dlci->state) {
1724 gsm_dlci_close(dlci);
1727 gsm_dlci_open(dlci);
1731 case DM: /* DM can be valid unsolicited */
1737 gsm_dlci_close(dlci);
1747 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1748 gsm_command(gsm, address, DM|PF);
1751 dlci->data(dlci, gsm->buf, gsm->len);
1764 * gsm0_receive - perform processing for non-transparency
1765 * @gsm: gsm data for this ldisc instance
1768 * Receive bytes in gsm mode 0
1771 static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1775 switch (gsm->state) {
1776 case GSM_SEARCH: /* SOF marker */
1777 if (c == GSM0_SOF) {
1778 gsm->state = GSM_ADDRESS;
1781 gsm->fcs = INIT_FCS;
1784 case GSM_ADDRESS: /* Address EA */
1785 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1786 if (gsm_read_ea(&gsm->address, c))
1787 gsm->state = GSM_CONTROL;
1789 case GSM_CONTROL: /* Control Byte */
1790 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1792 gsm->state = GSM_LEN0;
1794 case GSM_LEN0: /* Length EA */
1795 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1796 if (gsm_read_ea(&gsm->len, c)) {
1797 if (gsm->len > gsm->mru) {
1799 gsm->state = GSM_SEARCH;
1804 gsm->state = GSM_FCS;
1806 gsm->state = GSM_DATA;
1809 gsm->state = GSM_LEN1;
1812 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1814 gsm->len |= len << 7;
1815 if (gsm->len > gsm->mru) {
1817 gsm->state = GSM_SEARCH;
1822 gsm->state = GSM_FCS;
1824 gsm->state = GSM_DATA;
1826 case GSM_DATA: /* Data */
1827 gsm->buf[gsm->count++] = c;
1828 if (gsm->count == gsm->len)
1829 gsm->state = GSM_FCS;
1831 case GSM_FCS: /* FCS follows the packet */
1832 gsm->received_fcs = c;
1834 gsm->state = GSM_SSOF;
1837 if (c == GSM0_SOF) {
1838 gsm->state = GSM_SEARCH;
1846 * gsm1_receive - perform processing for non-transparency
1847 * @gsm: gsm data for this ldisc instance
1850 * Receive bytes in mode 1 (Advanced option)
1853 static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1855 if (c == GSM1_SOF) {
1856 /* EOF is only valid in frame if we have got to the data state
1857 and received at least one byte (the FCS) */
1858 if (gsm->state == GSM_DATA && gsm->count) {
1859 /* Extract the FCS */
1861 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1862 gsm->len = gsm->count;
1864 gsm->state = GSM_START;
1867 /* Any partial frame was a runt so go back to start */
1868 if (gsm->state != GSM_START) {
1870 gsm->state = GSM_START;
1872 /* A SOF in GSM_START means we are still reading idling or
1877 if (c == GSM1_ESCAPE) {
1882 /* Only an unescaped SOF gets us out of GSM search */
1883 if (gsm->state == GSM_SEARCH)
1887 c ^= GSM1_ESCAPE_BITS;
1890 switch (gsm->state) {
1891 case GSM_START: /* First byte after SOF */
1893 gsm->state = GSM_ADDRESS;
1894 gsm->fcs = INIT_FCS;
1896 case GSM_ADDRESS: /* Address continuation */
1897 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1898 if (gsm_read_ea(&gsm->address, c))
1899 gsm->state = GSM_CONTROL;
1901 case GSM_CONTROL: /* Control Byte */
1902 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1905 gsm->state = GSM_DATA;
1907 case GSM_DATA: /* Data */
1908 if (gsm->count > gsm->mru) { /* Allow one for the FCS */
1909 gsm->state = GSM_OVERRUN;
1912 gsm->buf[gsm->count++] = c;
1914 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */
1920 * gsm_error - handle tty error
1922 * @data: byte received (may be invalid)
1923 * @flag: error received
1925 * Handle an error in the receipt of data for a frame. Currently we just
1926 * go back to hunting for a SOF.
1928 * FIXME: better diagnostics ?
1931 static void gsm_error(struct gsm_mux *gsm,
1932 unsigned char data, unsigned char flag)
1934 gsm->state = GSM_SEARCH;
1939 * gsm_cleanup_mux - generic GSM protocol cleanup
1942 * Clean up the bits of the mux which are the same for all framing
1943 * protocols. Remove the mux from the mux table, stop all the timers
1944 * and then shut down each device hanging up the channels as we go.
1947 void gsm_cleanup_mux(struct gsm_mux *gsm)
1950 struct gsm_dlci *dlci = gsm->dlci[0];
1951 struct gsm_msg *txq;
1955 spin_lock(&gsm_mux_lock);
1956 for (i = 0; i < MAX_MUX; i++) {
1957 if (gsm_mux[i] == gsm) {
1962 spin_unlock(&gsm_mux_lock);
1963 WARN_ON(i == MAX_MUX);
1965 del_timer_sync(&gsm->t2_timer);
1966 /* Now we are sure T2 has stopped */
1969 gsm_dlci_begin_close(dlci);
1970 wait_event_interruptible(gsm->event,
1971 dlci->state == DLCI_CLOSED);
1973 /* Free up any link layer users */
1974 for (i = 0; i < NUM_DLCI; i++)
1976 gsm_dlci_free(gsm->dlci[i]);
1977 /* Now wipe the queues */
1978 for (txq = gsm->tx_head; txq != NULL; txq = gsm->tx_head) {
1979 gsm->tx_head = txq->next;
1982 gsm->tx_tail = NULL;
1984 EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
1987 * gsm_activate_mux - generic GSM setup
1990 * Set up the bits of the mux which are the same for all framing
1991 * protocols. Add the mux to the mux table so it can be opened and
1992 * finally kick off connecting to DLCI 0 on the modem.
1995 int gsm_activate_mux(struct gsm_mux *gsm)
1997 struct gsm_dlci *dlci;
2000 init_timer(&gsm->t2_timer);
2001 gsm->t2_timer.function = gsm_control_retransmit;
2002 gsm->t2_timer.data = (unsigned long)gsm;
2003 init_waitqueue_head(&gsm->event);
2004 spin_lock_init(&gsm->control_lock);
2005 spin_lock_init(&gsm->tx_lock);
2007 if (gsm->encoding == 0)
2008 gsm->receive = gsm0_receive;
2010 gsm->receive = gsm1_receive;
2011 gsm->error = gsm_error;
2013 spin_lock(&gsm_mux_lock);
2014 for (i = 0; i < MAX_MUX; i++) {
2015 if (gsm_mux[i] == NULL) {
2020 spin_unlock(&gsm_mux_lock);
2024 dlci = gsm_dlci_alloc(gsm, 0);
2027 gsm->dead = 0; /* Tty opens are now permissible */
2030 EXPORT_SYMBOL_GPL(gsm_activate_mux);
2033 * gsm_free_mux - free up a mux
2036 * Dispose of allocated resources for a dead mux. No refcounting
2037 * at present so the mux must be truly dead.
2039 void gsm_free_mux(struct gsm_mux *gsm)
2041 kfree(gsm->txframe);
2045 EXPORT_SYMBOL_GPL(gsm_free_mux);
2048 * gsm_alloc_mux - allocate a mux
2050 * Creates a new mux ready for activation.
2053 struct gsm_mux *gsm_alloc_mux(void)
2055 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2058 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2059 if (gsm->buf == NULL) {
2063 gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2064 if (gsm->txframe == NULL) {
2069 spin_lock_init(&gsm->lock);
2078 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
2080 gsm->dead = 1; /* Avoid early tty opens */
2084 EXPORT_SYMBOL_GPL(gsm_alloc_mux);
2087 * gsmld_output - write to link
2089 * @data: bytes to output
2092 * Write a block of data from the GSM mux to the data channel. This
2093 * will eventually be serialized from above but at the moment isn't.
2096 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2098 if (tty_write_room(gsm->tty) < len) {
2099 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2103 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET,
2105 gsm->tty->ops->write(gsm->tty, data, len);
2110 * gsmld_attach_gsm - mode set up
2111 * @tty: our tty structure
2114 * Set up the MUX for basic mode and commence connecting to the
2115 * modem. Currently called from the line discipline set up but
2116 * will need moving to an ioctl path.
2119 static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2123 gsm->tty = tty_kref_get(tty);
2124 gsm->output = gsmld_output;
2125 ret = gsm_activate_mux(gsm);
2127 tty_kref_put(gsm->tty);
2133 * gsmld_detach_gsm - stop doing 0710 mux
2134 * @tty: tty attached to the mux
2137 * Shutdown and then clean up the resources used by the line discipline
2140 static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2142 WARN_ON(tty != gsm->tty);
2143 gsm_cleanup_mux(gsm);
2144 tty_kref_put(gsm->tty);
2148 static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2149 char *fp, int count)
2151 struct gsm_mux *gsm = tty->disc_data;
2152 const unsigned char *dp;
2159 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET,
2162 for (i = count, dp = cp, f = fp; i; i--, dp++) {
2166 gsm->receive(gsm, *dp);
2172 gsm->error(gsm, *dp, flags);
2175 WARN_ONCE("%s: unknown flag %d\n",
2176 tty_name(tty, buf), flags);
2180 /* FASYNC if needed ? */
2181 /* If clogged call tty_throttle(tty); */
2185 * gsmld_chars_in_buffer - report available bytes
2188 * Report the number of characters buffered to be delivered to user
2189 * at this instant in time.
2194 static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
2200 * gsmld_flush_buffer - clean input queue
2201 * @tty: terminal device
2203 * Flush the input buffer. Called when the line discipline is
2204 * being closed, when the tty layer wants the buffer flushed (eg
2208 static void gsmld_flush_buffer(struct tty_struct *tty)
2213 * gsmld_close - close the ldisc for this tty
2216 * Called from the terminal layer when this line discipline is
2217 * being shut down, either because of a close or becsuse of a
2218 * discipline change. The function will not be called while other
2219 * ldisc methods are in progress.
2222 static void gsmld_close(struct tty_struct *tty)
2224 struct gsm_mux *gsm = tty->disc_data;
2226 gsmld_detach_gsm(tty, gsm);
2228 gsmld_flush_buffer(tty);
2229 /* Do other clean up here */
2234 * gsmld_open - open an ldisc
2235 * @tty: terminal to open
2237 * Called when this line discipline is being attached to the
2238 * terminal device. Can sleep. Called serialized so that no
2239 * other events will occur in parallel. No further open will occur
2243 static int gsmld_open(struct tty_struct *tty)
2245 struct gsm_mux *gsm;
2247 if (tty->ops->write == NULL)
2250 /* Attach our ldisc data */
2251 gsm = gsm_alloc_mux();
2255 tty->disc_data = gsm;
2256 tty->receive_room = 65536;
2258 /* Attach the initial passive connection */
2260 return gsmld_attach_gsm(tty, gsm);
2264 * gsmld_write_wakeup - asynchronous I/O notifier
2267 * Required for the ptys, serial driver etc. since processes
2268 * that attach themselves to the master and rely on ASYNC
2269 * IO must be woken up
2272 static void gsmld_write_wakeup(struct tty_struct *tty)
2274 struct gsm_mux *gsm = tty->disc_data;
2275 unsigned long flags;
2278 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2279 spin_lock_irqsave(&gsm->tx_lock, flags);
2281 if (gsm->tx_bytes < TX_THRESH_LO) {
2282 gsm_dlci_data_sweep(gsm);
2284 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2288 * gsmld_read - read function for tty
2290 * @file: file object
2291 * @buf: userspace buffer pointer
2294 * Perform reads for the line discipline. We are guaranteed that the
2295 * line discipline will not be closed under us but we may get multiple
2296 * parallel readers and must handle this ourselves. We may also get
2297 * a hangup. Always called in user context, may sleep.
2299 * This code must be sure never to sleep through a hangup.
2302 static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2303 unsigned char __user *buf, size_t nr)
2309 * gsmld_write - write function for tty
2311 * @file: file object
2312 * @buf: userspace buffer pointer
2315 * Called when the owner of the device wants to send a frame
2316 * itself (or some other control data). The data is transferred
2317 * as-is and must be properly framed and checksummed as appropriate
2318 * by userspace. Frames are either sent whole or not at all as this
2319 * avoids pain user side.
2322 static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2323 const unsigned char *buf, size_t nr)
2325 int space = tty_write_room(tty);
2327 return tty->ops->write(tty, buf, nr);
2328 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2333 * gsmld_poll - poll method for N_GSM0710
2334 * @tty: terminal device
2335 * @file: file accessing it
2338 * Called when the line discipline is asked to poll() for data or
2339 * for special events. This code is not serialized with respect to
2340 * other events save open/close.
2342 * This code must be sure never to sleep through a hangup.
2343 * Called without the kernel lock held - fine
2346 static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2349 unsigned int mask = 0;
2350 struct gsm_mux *gsm = tty->disc_data;
2352 poll_wait(file, &tty->read_wait, wait);
2353 poll_wait(file, &tty->write_wait, wait);
2354 if (tty_hung_up_p(file))
2356 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2357 mask |= POLLOUT | POLLWRNORM;
2363 static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2364 struct gsm_config *c)
2367 int need_restart = 0;
2369 /* Stuff we don't support yet - UI or I frame transport, windowing */
2370 if ((c->adaption != 1 && c->adaption != 2) || c->k)
2372 /* Check the MRU/MTU range looks sane */
2373 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2377 if (c->encapsulation > 1) /* Basic, advanced, no I */
2379 if (c->initiator > 1)
2381 if (c->i == 0 || c->i > 2) /* UIH and UI only */
2384 * See what is needed for reconfiguration
2388 if (c->t1 != 0 && c->t1 != gsm->t1)
2390 if (c->t2 != 0 && c->t2 != gsm->t2)
2392 if (c->encapsulation != gsm->encoding)
2394 if (c->adaption != gsm->adaption)
2397 if (c->initiator != gsm->initiator)
2399 if (c->mru != gsm->mru)
2401 if (c->mtu != gsm->mtu)
2405 * Close down what is needed, restart and initiate the new
2409 if (need_close || need_restart) {
2410 gsm_dlci_begin_close(gsm->dlci[0]);
2411 /* This will timeout if the link is down due to N2 expiring */
2412 wait_event_interruptible(gsm->event,
2413 gsm->dlci[0]->state == DLCI_CLOSED);
2414 if (signal_pending(current))
2418 gsm_cleanup_mux(gsm);
2420 gsm->initiator = c->initiator;
2423 gsm->encoding = c->encapsulation;
2424 gsm->adaption = c->adaption;
2437 /* FIXME: We need to separate activation/deactivation from adding
2438 and removing from the mux array */
2440 gsm_activate_mux(gsm);
2441 if (gsm->initiator && need_close)
2442 gsm_dlci_begin_open(gsm->dlci[0]);
2446 static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2447 unsigned int cmd, unsigned long arg)
2449 struct gsm_config c;
2450 struct gsm_mux *gsm = tty->disc_data;
2453 case GSMIOC_GETCONF:
2454 memset(&c, 0, sizeof(c));
2455 c.adaption = gsm->adaption;
2456 c.encapsulation = gsm->encoding;
2457 c.initiator = gsm->initiator;
2460 c.t3 = 0; /* Not supported */
2462 if (gsm->ftype == UIH)
2466 pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
2470 if (copy_to_user((void *)arg, &c, sizeof(c)))
2473 case GSMIOC_SETCONF:
2474 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2476 return gsmld_config(tty, gsm, &c);
2478 return n_tty_ioctl_helper(tty, file, cmd, arg);
2483 /* Line discipline for real tty */
2484 struct tty_ldisc_ops tty_ldisc_packet = {
2485 .owner = THIS_MODULE,
2486 .magic = TTY_LDISC_MAGIC,
2489 .close = gsmld_close,
2490 .flush_buffer = gsmld_flush_buffer,
2491 .chars_in_buffer = gsmld_chars_in_buffer,
2493 .write = gsmld_write,
2494 .ioctl = gsmld_ioctl,
2496 .receive_buf = gsmld_receive_buf,
2497 .write_wakeup = gsmld_write_wakeup
2506 static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2509 struct gsm_control *ctrl;
2515 modembits[0] = len << 1 | EA; /* Data bytes */
2516 modembits[1] = dlci->addr << 2 | 3; /* DLCI, EA, 1 */
2517 modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2519 modembits[3] = brk << 4 | 2 | EA; /* Valid, EA */
2520 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2523 return gsm_control_wait(dlci->gsm, ctrl);
2526 static int gsm_carrier_raised(struct tty_port *port)
2528 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2529 /* Not yet open so no carrier info */
2530 if (dlci->state != DLCI_OPEN)
2534 return dlci->modem_rx & TIOCM_CD;
2537 static void gsm_dtr_rts(struct tty_port *port, int onoff)
2539 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2540 unsigned int modem_tx = dlci->modem_tx;
2542 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2544 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2545 if (modem_tx != dlci->modem_tx) {
2546 dlci->modem_tx = modem_tx;
2547 gsmtty_modem_update(dlci, 0);
2551 static const struct tty_port_operations gsm_port_ops = {
2552 .carrier_raised = gsm_carrier_raised,
2553 .dtr_rts = gsm_dtr_rts,
2557 static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2559 struct gsm_mux *gsm;
2560 struct gsm_dlci *dlci;
2561 struct tty_port *port;
2562 unsigned int line = tty->index;
2563 unsigned int mux = line >> 6;
2569 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2570 if (gsm_mux[mux] == NULL)
2572 if (line == 0 || line > 61) /* 62/63 reserved */
2577 dlci = gsm->dlci[line];
2579 dlci = gsm_dlci_alloc(gsm, line);
2584 tty->driver_data = dlci;
2585 tty_port_tty_set(port, tty);
2588 /* We could in theory open and close before we wait - eg if we get
2589 a DM straight back. This is ok as that will have caused a hangup */
2590 set_bit(ASYNCB_INITIALIZED, &port->flags);
2591 /* Start sending off SABM messages */
2592 gsm_dlci_begin_open(dlci);
2593 /* And wait for virtual carrier */
2594 return tty_port_block_til_ready(port, tty, filp);
2597 static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2599 struct gsm_dlci *dlci = tty->driver_data;
2602 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
2604 gsm_dlci_begin_close(dlci);
2605 tty_port_close_end(&dlci->port, tty);
2606 tty_port_tty_set(&dlci->port, NULL);
2609 static void gsmtty_hangup(struct tty_struct *tty)
2611 struct gsm_dlci *dlci = tty->driver_data;
2612 tty_port_hangup(&dlci->port);
2613 gsm_dlci_begin_close(dlci);
2616 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2619 struct gsm_dlci *dlci = tty->driver_data;
2620 /* Stuff the bytes into the fifo queue */
2621 int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
2622 /* Need to kick the channel */
2623 gsm_dlci_data_kick(dlci);
2627 static int gsmtty_write_room(struct tty_struct *tty)
2629 struct gsm_dlci *dlci = tty->driver_data;
2630 return TX_SIZE - kfifo_len(dlci->fifo);
2633 static int gsmtty_chars_in_buffer(struct tty_struct *tty)
2635 struct gsm_dlci *dlci = tty->driver_data;
2636 return kfifo_len(dlci->fifo);
2639 static void gsmtty_flush_buffer(struct tty_struct *tty)
2641 struct gsm_dlci *dlci = tty->driver_data;
2642 /* Caution needed: If we implement reliable transport classes
2643 then the data being transmitted can't simply be junked once
2644 it has first hit the stack. Until then we can just blow it
2646 kfifo_reset(dlci->fifo);
2647 /* Need to unhook this DLCI from the transmit queue logic */
2650 static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
2652 /* The FIFO handles the queue so the kernel will do the right
2653 thing waiting on chars_in_buffer before calling us. No work
2657 static int gsmtty_tiocmget(struct tty_struct *tty)
2659 struct gsm_dlci *dlci = tty->driver_data;
2660 return dlci->modem_rx;
2663 static int gsmtty_tiocmset(struct tty_struct *tty,
2664 unsigned int set, unsigned int clear)
2666 struct gsm_dlci *dlci = tty->driver_data;
2667 unsigned int modem_tx = dlci->modem_tx;
2672 if (modem_tx != dlci->modem_tx) {
2673 dlci->modem_tx = modem_tx;
2674 return gsmtty_modem_update(dlci, 0);
2680 static int gsmtty_ioctl(struct tty_struct *tty,
2681 unsigned int cmd, unsigned long arg)
2683 return -ENOIOCTLCMD;
2686 static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
2688 /* For the moment its fixed. In actual fact the speed information
2689 for the virtual channel can be propogated in both directions by
2690 the RPN control message. This however rapidly gets nasty as we
2691 then have to remap modem signals each way according to whether
2692 our virtual cable is null modem etc .. */
2693 tty_termios_copy_hw(tty->termios, old);
2696 static void gsmtty_throttle(struct tty_struct *tty)
2698 struct gsm_dlci *dlci = tty->driver_data;
2699 if (tty->termios->c_cflag & CRTSCTS)
2700 dlci->modem_tx &= ~TIOCM_DTR;
2701 dlci->throttled = 1;
2702 /* Send an MSC with DTR cleared */
2703 gsmtty_modem_update(dlci, 0);
2706 static void gsmtty_unthrottle(struct tty_struct *tty)
2708 struct gsm_dlci *dlci = tty->driver_data;
2709 if (tty->termios->c_cflag & CRTSCTS)
2710 dlci->modem_tx |= TIOCM_DTR;
2711 dlci->throttled = 0;
2712 /* Send an MSC with DTR set */
2713 gsmtty_modem_update(dlci, 0);
2716 static int gsmtty_break_ctl(struct tty_struct *tty, int state)
2718 struct gsm_dlci *dlci = tty->driver_data;
2719 int encode = 0; /* Off */
2721 if (state == -1) /* "On indefinitely" - we can't encode this
2724 else if (state > 0) {
2725 encode = state / 200; /* mS to encoding */
2727 encode = 0x0F; /* Best effort */
2729 return gsmtty_modem_update(dlci, encode);
2732 static struct tty_driver *gsm_tty_driver;
2734 /* Virtual ttys for the demux */
2735 static const struct tty_operations gsmtty_ops = {
2736 .open = gsmtty_open,
2737 .close = gsmtty_close,
2738 .write = gsmtty_write,
2739 .write_room = gsmtty_write_room,
2740 .chars_in_buffer = gsmtty_chars_in_buffer,
2741 .flush_buffer = gsmtty_flush_buffer,
2742 .ioctl = gsmtty_ioctl,
2743 .throttle = gsmtty_throttle,
2744 .unthrottle = gsmtty_unthrottle,
2745 .set_termios = gsmtty_set_termios,
2746 .hangup = gsmtty_hangup,
2747 .wait_until_sent = gsmtty_wait_until_sent,
2748 .tiocmget = gsmtty_tiocmget,
2749 .tiocmset = gsmtty_tiocmset,
2750 .break_ctl = gsmtty_break_ctl,
2755 static int __init gsm_init(void)
2757 /* Fill in our line protocol discipline, and register it */
2758 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
2760 pr_err("n_gsm: can't register line discipline (err = %d)\n",
2765 gsm_tty_driver = alloc_tty_driver(256);
2766 if (!gsm_tty_driver) {
2767 tty_unregister_ldisc(N_GSM0710);
2768 pr_err("gsm_init: tty allocation failed.\n");
2771 gsm_tty_driver->owner = THIS_MODULE;
2772 gsm_tty_driver->driver_name = "gsmtty";
2773 gsm_tty_driver->name = "gsmtty";
2774 gsm_tty_driver->major = 0; /* Dynamic */
2775 gsm_tty_driver->minor_start = 0;
2776 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
2777 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
2778 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
2779 | TTY_DRIVER_HARDWARE_BREAK;
2780 gsm_tty_driver->init_termios = tty_std_termios;
2782 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
2783 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
2785 spin_lock_init(&gsm_mux_lock);
2787 if (tty_register_driver(gsm_tty_driver)) {
2788 put_tty_driver(gsm_tty_driver);
2789 tty_unregister_ldisc(N_GSM0710);
2790 pr_err("gsm_init: tty registration failed.\n");
2793 pr_debug("gsm_init: loaded as %d,%d.\n",
2794 gsm_tty_driver->major, gsm_tty_driver->minor_start);
2798 static void __exit gsm_exit(void)
2800 int status = tty_unregister_ldisc(N_GSM0710);
2802 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
2804 tty_unregister_driver(gsm_tty_driver);
2805 put_tty_driver(gsm_tty_driver);
2808 module_init(gsm_init);
2809 module_exit(gsm_exit);
2812 MODULE_LICENSE("GPL");
2813 MODULE_ALIAS_LDISC(N_GSM0710);