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>
55 module_param(debug, int, 0600);
57 /* Defaults: these are from the specification */
59 #define T1 10 /* 100mS */
60 #define T2 34 /* 333mS */
61 #define N2 3 /* Retry 3 times */
63 /* Use long timers for testing at low speed with debug on */
70 * Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte
71 * limits so this is plenty
75 /* SOF, ADDR, CTRL, LEN1, LEN2, ..., FCS, EOF */
76 #define PROT_OVERHEAD 7
77 #define GSM_NET_TX_TIMEOUT (HZ*10)
80 * struct gsm_mux_net - network interface
81 * @struct gsm_dlci* dlci
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[0];
106 * Each active data link has a gsm_dlci structure associated which ties
107 * the link layer to an optional tty (if the tty side is open). To avoid
108 * complexity right now these are only ever freed up when the mux is
111 * At the moment we don't free DLCI objects until the mux is torn down
112 * this avoid object life time issues but might be worth review later.
119 #define DLCI_CLOSED 0
120 #define DLCI_OPENING 1 /* Sending SABM not seen UA */
121 #define DLCI_OPEN 2 /* SABM/UA complete */
122 #define DLCI_CLOSING 3 /* Sending DISC not seen UA/DM */
127 #define DLCI_MODE_ABM 0 /* Normal Asynchronous Balanced Mode */
128 #define DLCI_MODE_ADM 1 /* Asynchronous Disconnected Mode */
129 spinlock_t lock; /* Protects the internal state */
130 struct timer_list t1; /* Retransmit timer for SABM and UA */
132 /* Uplink tty if active */
133 struct tty_port port; /* The tty bound to this DLCI if there is one */
134 struct kfifo *fifo; /* Queue fifo for the DLCI */
135 struct kfifo _fifo; /* For new fifo API porting only */
136 int adaption; /* Adaption layer in use */
138 u32 modem_rx; /* Our incoming virtual modem lines */
139 u32 modem_tx; /* Our outgoing modem lines */
140 int dead; /* Refuse re-open */
142 int throttled; /* Private copy of throttle state */
143 int constipated; /* Throttle status for outgoing */
145 struct sk_buff *skb; /* Frame being sent */
146 struct sk_buff_head skb_list; /* Queued frames */
147 /* Data handling callback */
148 void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
149 void (*prev_data)(struct gsm_dlci *dlci, u8 *data, int len);
150 struct net_device *net; /* network interface, if created */
153 /* DLCI 0, 62/63 are special or reserved see gsmtty_open */
158 * DLCI 0 is used to pass control blocks out of band of the data
159 * flow (and with a higher link priority). One command can be outstanding
160 * at a time and we use this structure to manage them. They are created
161 * and destroyed by the user context, and updated by the receive paths
166 u8 cmd; /* Command we are issuing */
167 u8 *data; /* Data for the command in case we retransmit */
168 int len; /* Length of block for retransmission */
169 int done; /* Done flag */
170 int error; /* Error if any */
174 * Each GSM mux we have is represented by this structure. If we are
175 * operating as an ldisc then we use this structure as our ldisc
176 * state. We need to sort out lifetimes and locking with respect
177 * to the gsm mux array. For now we don't free DLCI objects that
178 * have been instantiated until the mux itself is terminated.
180 * To consider further: tty open versus mux shutdown.
184 struct tty_struct *tty; /* The tty our ldisc is bound to */
190 /* Events on the GSM channel */
191 wait_queue_head_t event;
193 /* Bits for GSM mode decoding */
200 #define GSM_ADDRESS 2
201 #define GSM_CONTROL 3
205 #define GSM_OVERRUN 7
210 unsigned int address;
217 u8 *txframe; /* TX framing buffer */
219 /* Methods for the receiver side */
220 void (*receive)(struct gsm_mux *gsm, u8 ch);
221 void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
222 /* And transmit side */
223 int (*output)(struct gsm_mux *mux, u8 *data, int len);
228 int initiator; /* Did we initiate connection */
229 int dead; /* Has the mux been shut down */
230 struct gsm_dlci *dlci[NUM_DLCI];
231 int constipated; /* Asked by remote to shut up */
234 unsigned int tx_bytes; /* TX data outstanding */
235 #define TX_THRESH_HI 8192
236 #define TX_THRESH_LO 2048
237 struct list_head tx_list; /* Pending data packets */
239 /* Control messages */
240 struct timer_list t2_timer; /* Retransmit timer for commands */
241 int cretries; /* Command retry counter */
242 struct gsm_control *pending_cmd;/* Our current pending command */
243 spinlock_t control_lock; /* Protects the pending command */
246 int adaption; /* 1 or 2 supported */
247 u8 ftype; /* UI or UIH */
248 int t1, t2; /* Timers in 1/100th of a sec */
249 int n2; /* Retry count */
251 /* Statistics (not currently exposed) */
252 unsigned long bad_fcs;
253 unsigned long malformed;
254 unsigned long io_error;
255 unsigned long bad_size;
256 unsigned long unsupported;
261 * Mux objects - needed so that we can translate a tty index into the
262 * relevant mux and DLCI.
265 #define MAX_MUX 4 /* 256 minors */
266 static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */
267 static spinlock_t gsm_mux_lock;
269 static struct tty_driver *gsm_tty_driver;
272 * This section of the driver logic implements the GSM encodings
273 * both the basic and the 'advanced'. Reliable transport is not
281 /* I is special: the rest are ..*/
292 /* Channel commands */
294 #define CMD_TEST 0x11
297 #define CMD_FCOFF 0x31
300 #define CMD_FCON 0x51
305 /* Virtual modem bits */
312 #define GSM0_SOF 0xF9
313 #define GSM1_SOF 0x7E
314 #define GSM1_ESCAPE 0x7D
315 #define GSM1_ESCAPE_BITS 0x20
318 #define ISO_IEC_646_MASK 0x7F
320 static const struct tty_port_operations gsm_port_ops;
323 * CRC table for GSM 0710
326 static const u8 gsm_fcs8[256] = {
327 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
328 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
329 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
330 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
331 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
332 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
333 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
334 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
335 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
336 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
337 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
338 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
339 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
340 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
341 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
342 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
343 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
344 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
345 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
346 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
347 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
348 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
349 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
350 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
351 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
352 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
353 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
354 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
355 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
356 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
357 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
358 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
361 #define INIT_FCS 0xFF
362 #define GOOD_FCS 0xCF
365 * gsm_fcs_add - update FCS
369 * Update the FCS to include c. Uses the algorithm in the specification
373 static inline u8 gsm_fcs_add(u8 fcs, u8 c)
375 return gsm_fcs8[fcs ^ c];
379 * gsm_fcs_add_block - update FCS for a block
382 * @len: length of buffer
384 * Update the FCS to include c. Uses the algorithm in the specification
388 static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
391 fcs = gsm_fcs8[fcs ^ *c++];
396 * gsm_read_ea - read a byte into an EA
397 * @val: variable holding value
398 * c: byte going into the EA
400 * Processes one byte of an EA. Updates the passed variable
401 * and returns 1 if the EA is now completely read
404 static int gsm_read_ea(unsigned int *val, u8 c)
406 /* Add the next 7 bits into the value */
409 /* Was this the last byte of the EA 1 = yes*/
414 * gsm_encode_modem - encode modem data bits
415 * @dlci: DLCI to encode from
417 * Returns the correct GSM encoded modem status bits (6 bit field) for
418 * the current status of the DLCI and attached tty object
421 static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
424 /* FC is true flow control not modem bits */
427 if (dlci->modem_tx & TIOCM_DTR)
428 modembits |= MDM_RTC;
429 if (dlci->modem_tx & TIOCM_RTS)
430 modembits |= MDM_RTR;
431 if (dlci->modem_tx & TIOCM_RI)
433 if (dlci->modem_tx & TIOCM_CD || dlci->gsm->initiator)
439 * gsm_print_packet - display a frame for debug
440 * @hdr: header to print before decode
441 * @addr: address EA from the frame
442 * @cr: C/R bit from the frame
443 * @control: control including PF bit
444 * @data: following data bytes
445 * @dlen: length of data
447 * Displays a packet in human readable format for debugging purposes. The
448 * style is based on amateur radio LAP-B dump display.
451 static void gsm_print_packet(const char *hdr, int addr, int cr,
452 u8 control, const u8 *data, int dlen)
457 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
459 switch (control & ~PF) {
479 if (!(control & 0x01)) {
480 pr_cont("I N(S)%d N(R)%d",
481 (control & 0x0E) >> 1, (control & 0xE0) >> 5);
482 } else switch (control & 0x0F) {
484 pr_cont("RR(%d)", (control & 0xE0) >> 5);
487 pr_cont("RNR(%d)", (control & 0xE0) >> 5);
490 pr_cont("REJ(%d)", (control & 0xE0) >> 5);
493 pr_cont("[%02X]", control);
509 pr_cont("%02X ", *data++);
518 * Link level transmission side
522 * gsm_stuff_packet - bytestuff a packet
525 * @len: length of input
527 * Expand a buffer by bytestuffing it. The worst case size change
528 * is doubling and the caller is responsible for handing out
529 * suitable sized buffers.
532 static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
536 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
537 || (*input & ISO_IEC_646_MASK) == XON
538 || (*input & ISO_IEC_646_MASK) == XOFF) {
539 *output++ = GSM1_ESCAPE;
540 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
543 *output++ = *input++;
550 * gsm_send - send a control frame
552 * @addr: address for control frame
553 * @cr: command/response bit
554 * @control: control byte including PF bit
556 * Format up and transmit a control frame. These do not go via the
557 * queueing logic as they should be transmitted ahead of data when
560 * FIXME: Lock versus data TX path
563 static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
569 switch (gsm->encoding) {
572 cbuf[1] = (addr << 2) | (cr << 1) | EA;
574 cbuf[3] = EA; /* Length of data = 0 */
575 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
581 /* Control frame + packing (but not frame stuffing) in mode 1 */
582 ibuf[0] = (addr << 2) | (cr << 1) | EA;
584 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
585 /* Stuffing may double the size worst case */
586 len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
587 /* Now add the SOF markers */
589 cbuf[len + 1] = GSM1_SOF;
590 /* FIXME: we can omit the lead one in many cases */
597 gsm->output(gsm, cbuf, len);
598 gsm_print_packet("-->", addr, cr, control, NULL, 0);
602 * gsm_response - send a control response
604 * @addr: address for control frame
605 * @control: control byte including PF bit
607 * Format up and transmit a link level response frame.
610 static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
612 gsm_send(gsm, addr, 0, control);
616 * gsm_command - send a control command
618 * @addr: address for control frame
619 * @control: control byte including PF bit
621 * Format up and transmit a link level command frame.
624 static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
626 gsm_send(gsm, addr, 1, control);
629 /* Data transmission */
631 #define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
634 * gsm_data_alloc - allocate data frame
636 * @addr: DLCI address
637 * @len: length excluding header and FCS
638 * @ctrl: control byte
640 * Allocate a new data buffer for sending frames with data. Space is left
641 * at the front for header bytes but that is treated as an implementation
642 * detail and not for the high level code to use
645 static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
648 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
652 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */
656 INIT_LIST_HEAD(&m->list);
661 * gsm_data_kick - poke the queue
664 * The tty device has called us to indicate that room has appeared in
665 * the transmit queue. Ram more data into the pipe if we have any
666 * If we have been flow-stopped by a CMD_FCOFF, then we can only
667 * send messages on DLCI0 until CMD_FCON
669 * FIXME: lock against link layer control transmissions
672 static void gsm_data_kick(struct gsm_mux *gsm, struct gsm_dlci *dlci)
674 struct gsm_msg *msg, *nmsg;
677 list_for_each_entry_safe(msg, nmsg, &gsm->tx_list, list) {
678 if (gsm->constipated && msg->addr)
680 if (gsm->encoding != 0) {
681 gsm->txframe[0] = GSM1_SOF;
682 len = gsm_stuff_frame(msg->data,
683 gsm->txframe + 1, msg->len);
684 gsm->txframe[len + 1] = GSM1_SOF;
687 gsm->txframe[0] = GSM0_SOF;
688 memcpy(gsm->txframe + 1 , msg->data, msg->len);
689 gsm->txframe[msg->len + 1] = GSM0_SOF;
694 print_hex_dump_bytes("gsm_data_kick: ",
697 if (gsm->output(gsm, gsm->txframe, len) < 0)
699 /* FIXME: Can eliminate one SOF in many more cases */
700 gsm->tx_bytes -= msg->len;
702 list_del(&msg->list);
706 tty_port_tty_wakeup(&dlci->port);
710 for (i = 0; i < NUM_DLCI; i++)
712 tty_port_tty_wakeup(&gsm->dlci[i]->port);
718 * __gsm_data_queue - queue a UI or UIH frame
719 * @dlci: DLCI sending the data
720 * @msg: message queued
722 * Add data to the transmit queue and try and get stuff moving
723 * out of the mux tty if not already doing so. The Caller must hold
727 static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
729 struct gsm_mux *gsm = dlci->gsm;
731 u8 *fcs = dp + msg->len;
733 /* Fill in the header */
734 if (gsm->encoding == 0) {
736 *--dp = (msg->len << 1) | EA;
738 *--dp = (msg->len >> 7); /* bits 7 - 15 */
739 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */
745 *--dp = (msg->addr << 2) | 2 | EA;
747 *--dp = (msg->addr << 2) | EA;
748 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
749 /* Ugly protocol layering violation */
750 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
751 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
754 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
755 msg->data, msg->len);
757 /* Move the header back and adjust the length, also allow for the FCS
758 now tacked on the end */
759 msg->len += (msg->data - dp) + 1;
762 /* Add to the actual output queue */
763 list_add_tail(&msg->list, &gsm->tx_list);
764 gsm->tx_bytes += msg->len;
765 gsm_data_kick(gsm, dlci);
769 * gsm_data_queue - queue a UI or UIH frame
770 * @dlci: DLCI sending the data
771 * @msg: message queued
773 * Add data to the transmit queue and try and get stuff moving
774 * out of the mux tty if not already doing so. Take the
775 * the gsm tx lock and dlci lock.
778 static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
781 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
782 __gsm_data_queue(dlci, msg);
783 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
787 * gsm_dlci_data_output - try and push data out of a DLCI
789 * @dlci: the DLCI to pull data from
791 * Pull data from a DLCI and send it into the transmit queue if there
792 * is data. Keep to the MRU of the mux. This path handles the usual tty
793 * interface which is a byte stream with optional modem data.
795 * Caller must hold the tx_lock of the mux.
798 static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
802 int len, total_size, size;
803 int h = dlci->adaption - 1;
807 len = kfifo_len(dlci->fifo);
811 /* MTU/MRU count only the data bits */
817 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
818 /* FIXME: need a timer or something to kick this so it can't
819 get stuck with no work outstanding and no buffer free */
823 switch (dlci->adaption) {
824 case 1: /* Unstructured */
826 case 2: /* Unstructed with modem bits.
827 Always one byte as we never send inline break data */
828 *dp++ = (gsm_encode_modem(dlci) << 1) | EA;
831 WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
832 __gsm_data_queue(dlci, msg);
835 /* Bytes of data we used up */
840 * gsm_dlci_data_output_framed - try and push data out of a DLCI
842 * @dlci: the DLCI to pull data from
844 * Pull data from a DLCI and send it into the transmit queue if there
845 * is data. Keep to the MRU of the mux. This path handles framed data
846 * queued as skbuffs to the DLCI.
848 * Caller must hold the tx_lock of the mux.
851 static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
852 struct gsm_dlci *dlci)
857 int last = 0, first = 0;
860 /* One byte per frame is used for B/F flags */
861 if (dlci->adaption == 4)
864 /* dlci->skb is locked by tx_lock */
865 if (dlci->skb == NULL) {
866 dlci->skb = skb_dequeue_tail(&dlci->skb_list);
867 if (dlci->skb == NULL)
871 len = dlci->skb->len + overhead;
873 /* MTU/MRU count only the data bits */
874 if (len > gsm->mtu) {
875 if (dlci->adaption == 3) {
876 /* Over long frame, bin it */
877 dev_kfree_skb_any(dlci->skb);
885 size = len + overhead;
886 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
888 /* FIXME: need a timer or something to kick this so it can't
889 get stuck with no work outstanding and no buffer free */
891 skb_queue_tail(&dlci->skb_list, dlci->skb);
897 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
898 /* Flag byte to carry the start/end info */
899 *dp++ = last << 7 | first << 6 | 1; /* EA */
902 memcpy(dp, dlci->skb->data, len);
903 skb_pull(dlci->skb, len);
904 __gsm_data_queue(dlci, msg);
906 dev_kfree_skb_any(dlci->skb);
913 * gsm_dlci_data_sweep - look for data to send
916 * Sweep the GSM mux channels in priority order looking for ones with
917 * data to send. We could do with optimising this scan a bit. We aim
918 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
919 * TX_THRESH_LO we get called again
921 * FIXME: We should round robin between groups and in theory you can
922 * renegotiate DLCI priorities with optional stuff. Needs optimising.
925 static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
928 /* Priority ordering: We should do priority with RR of the groups */
931 while (i < NUM_DLCI) {
932 struct gsm_dlci *dlci;
934 if (gsm->tx_bytes > TX_THRESH_HI)
937 if (dlci == NULL || dlci->constipated) {
941 if (dlci->adaption < 3 && !dlci->net)
942 len = gsm_dlci_data_output(gsm, dlci);
944 len = gsm_dlci_data_output_framed(gsm, dlci);
947 /* DLCI empty - try the next */
954 * gsm_dlci_data_kick - transmit if possible
955 * @dlci: DLCI to kick
957 * Transmit data from this DLCI if the queue is empty. We can't rely on
958 * a tty wakeup except when we filled the pipe so we need to fire off
959 * new data ourselves in other cases.
962 static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
967 if (dlci->constipated)
970 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
971 /* If we have nothing running then we need to fire up */
972 sweep = (dlci->gsm->tx_bytes < TX_THRESH_LO);
973 if (dlci->gsm->tx_bytes == 0) {
975 gsm_dlci_data_output_framed(dlci->gsm, dlci);
977 gsm_dlci_data_output(dlci->gsm, dlci);
980 gsm_dlci_data_sweep(dlci->gsm);
981 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
985 * Control message processing
990 * gsm_control_reply - send a response frame to a control
992 * @cmd: the command to use
993 * @data: data to follow encoded info
994 * @dlen: length of data
996 * Encode up and queue a UI/UIH frame containing our response.
999 static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
1002 struct gsm_msg *msg;
1003 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
1006 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */
1007 msg->data[1] = (dlen << 1) | EA;
1008 memcpy(msg->data + 2, data, dlen);
1009 gsm_data_queue(gsm->dlci[0], msg);
1013 * gsm_process_modem - process received modem status
1014 * @tty: virtual tty bound to the DLCI
1015 * @dlci: DLCI to affect
1016 * @modem: modem bits (full EA)
1018 * Used when a modem control message or line state inline in adaption
1019 * layer 2 is processed. Sort out the local modem state and throttles
1022 static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
1023 u32 modem, int clen)
1029 /* The modem status command can either contain one octet (v.24 signals)
1030 or two octets (v.24 signals + break signals). The length field will
1031 either be 2 or 3 respectively. This is specified in section
1032 5.4.6.3.7 of the 27.010 mux spec. */
1035 modem = modem & 0x7f;
1038 modem = (modem >> 7) & 0x7f;
1041 /* Flow control/ready to communicate */
1042 fc = (modem & MDM_FC) || !(modem & MDM_RTR);
1043 if (fc && !dlci->constipated) {
1044 /* Need to throttle our output on this device */
1045 dlci->constipated = 1;
1046 } else if (!fc && dlci->constipated) {
1047 dlci->constipated = 0;
1048 gsm_dlci_data_kick(dlci);
1051 /* Map modem bits */
1052 if (modem & MDM_RTC)
1053 mlines |= TIOCM_DSR | TIOCM_DTR;
1054 if (modem & MDM_RTR)
1055 mlines |= TIOCM_RTS | TIOCM_CTS;
1061 /* Carrier drop -> hangup */
1063 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1068 tty_insert_flip_char(&dlci->port, 0, TTY_BREAK);
1069 dlci->modem_rx = mlines;
1073 * gsm_control_modem - modem status received
1075 * @data: data following command
1076 * @clen: command length
1078 * We have received a modem status control message. This is used by
1079 * the GSM mux protocol to pass virtual modem line status and optionally
1080 * to indicate break signals. Unpack it, convert to Linux representation
1081 * and if need be stuff a break message down the tty.
1084 static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1086 unsigned int addr = 0;
1087 unsigned int modem = 0;
1088 unsigned int brk = 0;
1089 struct gsm_dlci *dlci;
1092 struct tty_struct *tty;
1094 while (gsm_read_ea(&addr, *dp++) == 0) {
1099 /* Must be at least one byte following the EA */
1105 /* Closed port, or invalid ? */
1106 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1108 dlci = gsm->dlci[addr];
1110 while (gsm_read_ea(&modem, *dp++) == 0) {
1117 while (gsm_read_ea(&brk, *dp++) == 0) {
1123 modem |= (brk & 0x7f);
1125 tty = tty_port_tty_get(&dlci->port);
1126 gsm_process_modem(tty, dlci, modem, clen);
1131 gsm_control_reply(gsm, CMD_MSC, data, clen);
1135 * gsm_control_rls - remote line status
1138 * @clen: data length
1140 * The modem sends us a two byte message on the control channel whenever
1141 * it wishes to send us an error state from the virtual link. Stuff
1142 * this into the uplink tty if present
1145 static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1147 struct tty_port *port;
1148 unsigned int addr = 0;
1153 while (gsm_read_ea(&addr, *dp++) == 0) {
1158 /* Must be at least one byte following ea */
1163 /* Closed port, or invalid ? */
1164 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1168 if ((bits & 1) == 0)
1171 port = &gsm->dlci[addr]->port;
1174 tty_insert_flip_char(port, 0, TTY_OVERRUN);
1176 tty_insert_flip_char(port, 0, TTY_PARITY);
1178 tty_insert_flip_char(port, 0, TTY_FRAME);
1180 tty_flip_buffer_push(port);
1182 gsm_control_reply(gsm, CMD_RLS, data, clen);
1185 static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1188 * gsm_control_message - DLCI 0 control processing
1190 * @command: the command EA
1191 * @data: data beyond the command/length EAs
1194 * Input processor for control messages from the other end of the link.
1195 * Processes the incoming request and queues a response frame or an
1196 * NSC response if not supported
1199 static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1203 unsigned long flags;
1207 struct gsm_dlci *dlci = gsm->dlci[0];
1208 /* Modem wishes to close down */
1212 gsm_dlci_begin_close(dlci);
1217 /* Modem wishes to test, reply with the data */
1218 gsm_control_reply(gsm, CMD_TEST, data, clen);
1221 /* Modem can accept data again */
1222 gsm->constipated = 0;
1223 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1224 /* Kick the link in case it is idling */
1225 spin_lock_irqsave(&gsm->tx_lock, flags);
1226 gsm_data_kick(gsm, NULL);
1227 spin_unlock_irqrestore(&gsm->tx_lock, flags);
1230 /* Modem wants us to STFU */
1231 gsm->constipated = 1;
1232 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1235 /* Out of band modem line change indicator for a DLCI */
1236 gsm_control_modem(gsm, data, clen);
1239 /* Out of band error reception for a DLCI */
1240 gsm_control_rls(gsm, data, clen);
1243 /* Modem wishes to enter power saving state */
1244 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1246 /* Optional unsupported commands */
1247 case CMD_PN: /* Parameter negotiation */
1248 case CMD_RPN: /* Remote port negotiation */
1249 case CMD_SNC: /* Service negotiation command */
1251 /* Reply to bad commands with an NSC */
1253 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1259 * gsm_control_response - process a response to our control
1261 * @command: the command (response) EA
1262 * @data: data beyond the command/length EA
1265 * Process a response to an outstanding command. We only allow a single
1266 * control message in flight so this is fairly easy. All the clean up
1267 * is done by the caller, we just update the fields, flag it as done
1271 static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1274 struct gsm_control *ctrl;
1275 unsigned long flags;
1277 spin_lock_irqsave(&gsm->control_lock, flags);
1279 ctrl = gsm->pending_cmd;
1280 /* Does the reply match our command */
1282 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1283 /* Our command was replied to, kill the retry timer */
1284 del_timer(&gsm->t2_timer);
1285 gsm->pending_cmd = NULL;
1286 /* Rejected by the other end */
1287 if (command == CMD_NSC)
1288 ctrl->error = -EOPNOTSUPP;
1290 wake_up(&gsm->event);
1292 spin_unlock_irqrestore(&gsm->control_lock, flags);
1296 * gsm_control_transmit - send control packet
1298 * @ctrl: frame to send
1300 * Send out a pending control command (called under control lock)
1303 static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1305 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 2, gsm->ftype);
1308 msg->data[0] = (ctrl->cmd << 1) | CR | EA; /* command */
1309 msg->data[1] = (ctrl->len << 1) | EA;
1310 memcpy(msg->data + 2, ctrl->data, ctrl->len);
1311 gsm_data_queue(gsm->dlci[0], msg);
1315 * gsm_control_retransmit - retransmit a control frame
1316 * @data: pointer to our gsm object
1318 * Called off the T2 timer expiry in order to retransmit control frames
1319 * that have been lost in the system somewhere. The control_lock protects
1320 * us from colliding with another sender or a receive completion event.
1321 * In that situation the timer may still occur in a small window but
1322 * gsm->pending_cmd will be NULL and we just let the timer expire.
1325 static void gsm_control_retransmit(struct timer_list *t)
1327 struct gsm_mux *gsm = from_timer(gsm, t, t2_timer);
1328 struct gsm_control *ctrl;
1329 unsigned long flags;
1330 spin_lock_irqsave(&gsm->control_lock, flags);
1331 ctrl = gsm->pending_cmd;
1333 if (gsm->cretries == 0) {
1334 gsm->pending_cmd = NULL;
1335 ctrl->error = -ETIMEDOUT;
1337 spin_unlock_irqrestore(&gsm->control_lock, flags);
1338 wake_up(&gsm->event);
1342 gsm_control_transmit(gsm, ctrl);
1343 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1345 spin_unlock_irqrestore(&gsm->control_lock, flags);
1349 * gsm_control_send - send a control frame on DLCI 0
1350 * @gsm: the GSM channel
1351 * @command: command to send including CR bit
1352 * @data: bytes of data (must be kmalloced)
1353 * @len: length of the block to send
1355 * Queue and dispatch a control command. Only one command can be
1356 * active at a time. In theory more can be outstanding but the matching
1357 * gets really complicated so for now stick to one outstanding.
1360 static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1361 unsigned int command, u8 *data, int clen)
1363 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1365 unsigned long flags;
1369 wait_event(gsm->event, gsm->pending_cmd == NULL);
1370 spin_lock_irqsave(&gsm->control_lock, flags);
1371 if (gsm->pending_cmd != NULL) {
1372 spin_unlock_irqrestore(&gsm->control_lock, flags);
1375 ctrl->cmd = command;
1378 gsm->pending_cmd = ctrl;
1380 /* If DLCI0 is in ADM mode skip retries, it won't respond */
1381 if (gsm->dlci[0]->mode == DLCI_MODE_ADM)
1384 gsm->cretries = gsm->n2;
1386 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1387 gsm_control_transmit(gsm, ctrl);
1388 spin_unlock_irqrestore(&gsm->control_lock, flags);
1393 * gsm_control_wait - wait for a control to finish
1395 * @control: control we are waiting on
1397 * Waits for the control to complete or time out. Frees any used
1398 * resources and returns 0 for success, or an error if the remote
1399 * rejected or ignored the request.
1402 static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1405 wait_event(gsm->event, control->done == 1);
1406 err = control->error;
1413 * DLCI level handling: Needs krefs
1417 * State transitions and timers
1421 * gsm_dlci_close - a DLCI has closed
1422 * @dlci: DLCI that closed
1424 * Perform processing when moving a DLCI into closed state. If there
1425 * is an attached tty this is hung up
1428 static void gsm_dlci_close(struct gsm_dlci *dlci)
1430 del_timer(&dlci->t1);
1432 pr_debug("DLCI %d goes closed.\n", dlci->addr);
1433 dlci->state = DLCI_CLOSED;
1434 if (dlci->addr != 0) {
1435 tty_port_tty_hangup(&dlci->port, false);
1436 kfifo_reset(dlci->fifo);
1438 dlci->gsm->dead = 1;
1439 wake_up(&dlci->gsm->event);
1440 /* A DLCI 0 close is a MUX termination so we need to kick that
1441 back to userspace somehow */
1445 * gsm_dlci_open - a DLCI has opened
1446 * @dlci: DLCI that opened
1448 * Perform processing when moving a DLCI into open state.
1451 static void gsm_dlci_open(struct gsm_dlci *dlci)
1453 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1455 del_timer(&dlci->t1);
1456 /* This will let a tty open continue */
1457 dlci->state = DLCI_OPEN;
1459 pr_debug("DLCI %d goes open.\n", dlci->addr);
1460 wake_up(&dlci->gsm->event);
1464 * gsm_dlci_t1 - T1 timer expiry
1465 * @dlci: DLCI that opened
1467 * The T1 timer handles retransmits of control frames (essentially of
1468 * SABM and DISC). We resend the command until the retry count runs out
1469 * in which case an opening port goes back to closed and a closing port
1470 * is simply put into closed state (any further frames from the other
1471 * end will get a DM response)
1473 * Some control dlci can stay in ADM mode with other dlci working just
1474 * fine. In that case we can just keep the control dlci open after the
1475 * DLCI_OPENING retries time out.
1478 static void gsm_dlci_t1(struct timer_list *t)
1480 struct gsm_dlci *dlci = from_timer(dlci, t, t1);
1481 struct gsm_mux *gsm = dlci->gsm;
1483 switch (dlci->state) {
1486 if (dlci->retries) {
1487 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1488 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1489 } else if (!dlci->addr && gsm->control == (DM | PF)) {
1491 pr_info("DLCI %d opening in ADM mode.\n",
1493 dlci->mode = DLCI_MODE_ADM;
1494 gsm_dlci_open(dlci);
1496 gsm_dlci_begin_close(dlci); /* prevent half open link */
1502 if (dlci->retries) {
1503 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1504 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1506 gsm_dlci_close(dlci);
1512 * gsm_dlci_begin_open - start channel open procedure
1513 * @dlci: DLCI to open
1515 * Commence opening a DLCI from the Linux side. We issue SABM messages
1516 * to the modem which should then reply with a UA or ADM, at which point
1517 * we will move into open state. Opening is done asynchronously with retry
1518 * running off timers and the responses.
1521 static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1523 struct gsm_mux *gsm = dlci->gsm;
1524 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1526 dlci->retries = gsm->n2;
1527 dlci->state = DLCI_OPENING;
1528 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1529 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1533 * gsm_dlci_begin_close - start channel open procedure
1534 * @dlci: DLCI to open
1536 * Commence closing a DLCI from the Linux side. We issue DISC messages
1537 * to the modem which should then reply with a UA, at which point we
1538 * will move into closed state. Closing is done asynchronously with retry
1539 * off timers. We may also receive a DM reply from the other end which
1540 * indicates the channel was already closed.
1543 static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1545 struct gsm_mux *gsm = dlci->gsm;
1546 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1548 dlci->retries = gsm->n2;
1549 dlci->state = DLCI_CLOSING;
1550 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1551 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1555 * gsm_dlci_data - data arrived
1557 * @data: block of bytes received
1558 * @len: length of received block
1560 * A UI or UIH frame has arrived which contains data for a channel
1561 * other than the control channel. If the relevant virtual tty is
1562 * open we shovel the bits down it, if not we drop them.
1565 static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int clen)
1568 struct tty_port *port = &dlci->port;
1569 struct tty_struct *tty;
1570 unsigned int modem = 0;
1574 pr_debug("%d bytes for tty\n", len);
1575 switch (dlci->adaption) {
1576 /* Unsupported types */
1577 /* Packetised interruptible data */
1580 /* Packetised uininterruptible voice/data */
1583 /* Asynchronous serial with line state in each frame */
1585 while (gsm_read_ea(&modem, *data++) == 0) {
1590 tty = tty_port_tty_get(port);
1592 gsm_process_modem(tty, dlci, modem, clen);
1595 /* Line state will go via DLCI 0 controls only */
1598 tty_insert_flip_string(port, data, len);
1599 tty_flip_buffer_push(port);
1604 * gsm_dlci_control - data arrived on control channel
1606 * @data: block of bytes received
1607 * @len: length of received block
1609 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1610 * control channel. This should contain a command EA followed by
1611 * control data bytes. The command EA contains a command/response bit
1612 * and we divide up the work accordingly.
1615 static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1617 /* See what command is involved */
1618 unsigned int command = 0;
1620 if (gsm_read_ea(&command, *data++) == 1) {
1623 /* FIXME: this is properly an EA */
1625 /* Malformed command ? */
1629 gsm_control_message(dlci->gsm, command,
1632 gsm_control_response(dlci->gsm, command,
1640 * Allocate/Free DLCI channels
1644 * gsm_dlci_alloc - allocate a DLCI
1646 * @addr: address of the DLCI
1648 * Allocate and install a new DLCI object into the GSM mux.
1650 * FIXME: review locking races
1653 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1655 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1658 spin_lock_init(&dlci->lock);
1659 mutex_init(&dlci->mutex);
1660 dlci->fifo = &dlci->_fifo;
1661 if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1666 skb_queue_head_init(&dlci->skb_list);
1667 timer_setup(&dlci->t1, gsm_dlci_t1, 0);
1668 tty_port_init(&dlci->port);
1669 dlci->port.ops = &gsm_port_ops;
1672 dlci->adaption = gsm->adaption;
1673 dlci->state = DLCI_CLOSED;
1675 dlci->data = gsm_dlci_data;
1677 dlci->data = gsm_dlci_command;
1678 gsm->dlci[addr] = dlci;
1683 * gsm_dlci_free - free DLCI
1684 * @dlci: DLCI to free
1690 static void gsm_dlci_free(struct tty_port *port)
1692 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
1694 del_timer_sync(&dlci->t1);
1695 dlci->gsm->dlci[dlci->addr] = NULL;
1696 kfifo_free(dlci->fifo);
1697 while ((dlci->skb = skb_dequeue(&dlci->skb_list)))
1698 dev_kfree_skb(dlci->skb);
1702 static inline void dlci_get(struct gsm_dlci *dlci)
1704 tty_port_get(&dlci->port);
1707 static inline void dlci_put(struct gsm_dlci *dlci)
1709 tty_port_put(&dlci->port);
1712 static void gsm_destroy_network(struct gsm_dlci *dlci);
1715 * gsm_dlci_release - release DLCI
1716 * @dlci: DLCI to destroy
1718 * Release a DLCI. Actual free is deferred until either
1719 * mux is closed or tty is closed - whichever is last.
1723 static void gsm_dlci_release(struct gsm_dlci *dlci)
1725 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1727 mutex_lock(&dlci->mutex);
1728 gsm_destroy_network(dlci);
1729 mutex_unlock(&dlci->mutex);
1733 tty_port_tty_set(&dlci->port, NULL);
1736 dlci->state = DLCI_CLOSED;
1741 * LAPBish link layer logic
1745 * gsm_queue - a GSM frame is ready to process
1746 * @gsm: pointer to our gsm mux
1748 * At this point in time a frame has arrived and been demangled from
1749 * the line encoding. All the differences between the encodings have
1750 * been handled below us and the frame is unpacked into the structures.
1751 * The fcs holds the header FCS but any data FCS must be added here.
1754 static void gsm_queue(struct gsm_mux *gsm)
1756 struct gsm_dlci *dlci;
1759 /* We have to sneak a look at the packet body to do the FCS.
1760 A somewhat layering violation in the spec */
1762 if ((gsm->control & ~PF) == UI)
1763 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1764 if (gsm->encoding == 0) {
1765 /* WARNING: gsm->received_fcs is used for
1766 gsm->encoding = 0 only.
1767 In this case it contain the last piece of data
1768 required to generate final CRC */
1769 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1771 if (gsm->fcs != GOOD_FCS) {
1774 pr_debug("BAD FCS %02x\n", gsm->fcs);
1777 address = gsm->address >> 1;
1778 if (address >= NUM_DLCI)
1781 cr = gsm->address & 1; /* C/R bit */
1783 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1785 cr ^= 1 - gsm->initiator; /* Flip so 1 always means command */
1786 dlci = gsm->dlci[address];
1788 switch (gsm->control) {
1793 dlci = gsm_dlci_alloc(gsm, address);
1797 gsm_response(gsm, address, DM);
1799 gsm_response(gsm, address, UA);
1800 gsm_dlci_open(dlci);
1806 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1807 gsm_response(gsm, address, DM);
1810 /* Real close complete */
1811 gsm_response(gsm, address, UA);
1812 gsm_dlci_close(dlci);
1815 if (cr == 0 || dlci == NULL)
1817 switch (dlci->state) {
1819 gsm_dlci_close(dlci);
1822 gsm_dlci_open(dlci);
1826 case DM: /* DM can be valid unsolicited */
1832 gsm_dlci_close(dlci);
1842 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1843 gsm_command(gsm, address, DM|PF);
1846 dlci->data(dlci, gsm->buf, gsm->len);
1859 * gsm0_receive - perform processing for non-transparency
1860 * @gsm: gsm data for this ldisc instance
1863 * Receive bytes in gsm mode 0
1866 static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1870 switch (gsm->state) {
1871 case GSM_SEARCH: /* SOF marker */
1872 if (c == GSM0_SOF) {
1873 gsm->state = GSM_ADDRESS;
1876 gsm->fcs = INIT_FCS;
1879 case GSM_ADDRESS: /* Address EA */
1880 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1881 if (gsm_read_ea(&gsm->address, c))
1882 gsm->state = GSM_CONTROL;
1884 case GSM_CONTROL: /* Control Byte */
1885 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1887 gsm->state = GSM_LEN0;
1889 case GSM_LEN0: /* Length EA */
1890 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1891 if (gsm_read_ea(&gsm->len, c)) {
1892 if (gsm->len > gsm->mru) {
1894 gsm->state = GSM_SEARCH;
1899 gsm->state = GSM_FCS;
1901 gsm->state = GSM_DATA;
1904 gsm->state = GSM_LEN1;
1907 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1909 gsm->len |= len << 7;
1910 if (gsm->len > gsm->mru) {
1912 gsm->state = GSM_SEARCH;
1917 gsm->state = GSM_FCS;
1919 gsm->state = GSM_DATA;
1921 case GSM_DATA: /* Data */
1922 gsm->buf[gsm->count++] = c;
1923 if (gsm->count == gsm->len)
1924 gsm->state = GSM_FCS;
1926 case GSM_FCS: /* FCS follows the packet */
1927 gsm->received_fcs = c;
1929 gsm->state = GSM_SSOF;
1932 if (c == GSM0_SOF) {
1933 gsm->state = GSM_SEARCH;
1941 * gsm1_receive - perform processing for non-transparency
1942 * @gsm: gsm data for this ldisc instance
1945 * Receive bytes in mode 1 (Advanced option)
1948 static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1950 if (c == GSM1_SOF) {
1951 /* EOF is only valid in frame if we have got to the data state
1952 and received at least one byte (the FCS) */
1953 if (gsm->state == GSM_DATA && gsm->count) {
1954 /* Extract the FCS */
1956 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1957 gsm->len = gsm->count;
1959 gsm->state = GSM_START;
1962 /* Any partial frame was a runt so go back to start */
1963 if (gsm->state != GSM_START) {
1964 if (gsm->state != GSM_SEARCH)
1966 gsm->state = GSM_START;
1968 /* A SOF in GSM_START means we are still reading idling or
1973 if (c == GSM1_ESCAPE) {
1978 /* Only an unescaped SOF gets us out of GSM search */
1979 if (gsm->state == GSM_SEARCH)
1983 c ^= GSM1_ESCAPE_BITS;
1986 switch (gsm->state) {
1987 case GSM_START: /* First byte after SOF */
1989 gsm->state = GSM_ADDRESS;
1990 gsm->fcs = INIT_FCS;
1992 case GSM_ADDRESS: /* Address continuation */
1993 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1994 if (gsm_read_ea(&gsm->address, c))
1995 gsm->state = GSM_CONTROL;
1997 case GSM_CONTROL: /* Control Byte */
1998 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
2001 gsm->state = GSM_DATA;
2003 case GSM_DATA: /* Data */
2004 if (gsm->count > gsm->mru) { /* Allow one for the FCS */
2005 gsm->state = GSM_OVERRUN;
2008 gsm->buf[gsm->count++] = c;
2010 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */
2016 * gsm_error - handle tty error
2018 * @data: byte received (may be invalid)
2019 * @flag: error received
2021 * Handle an error in the receipt of data for a frame. Currently we just
2022 * go back to hunting for a SOF.
2024 * FIXME: better diagnostics ?
2027 static void gsm_error(struct gsm_mux *gsm,
2028 unsigned char data, unsigned char flag)
2030 gsm->state = GSM_SEARCH;
2034 static int gsm_disconnect(struct gsm_mux *gsm)
2036 struct gsm_dlci *dlci = gsm->dlci[0];
2037 struct gsm_control *gc;
2042 /* In theory disconnecting DLCI 0 is sufficient but for some
2043 modems this is apparently not the case. */
2044 gc = gsm_control_send(gsm, CMD_CLD, NULL, 0);
2046 gsm_control_wait(gsm, gc);
2048 del_timer_sync(&gsm->t2_timer);
2049 /* Now we are sure T2 has stopped */
2051 gsm_dlci_begin_close(dlci);
2052 wait_event_interruptible(gsm->event,
2053 dlci->state == DLCI_CLOSED);
2055 if (signal_pending(current))
2062 * gsm_cleanup_mux - generic GSM protocol cleanup
2065 * Clean up the bits of the mux which are the same for all framing
2066 * protocols. Remove the mux from the mux table, stop all the timers
2067 * and then shut down each device hanging up the channels as we go.
2070 static void gsm_cleanup_mux(struct gsm_mux *gsm)
2073 struct gsm_dlci *dlci = gsm->dlci[0];
2074 struct gsm_msg *txq, *ntxq;
2078 spin_lock(&gsm_mux_lock);
2079 for (i = 0; i < MAX_MUX; i++) {
2080 if (gsm_mux[i] == gsm) {
2085 spin_unlock(&gsm_mux_lock);
2086 /* open failed before registering => nothing to do */
2090 del_timer_sync(&gsm->t2_timer);
2091 /* Now we are sure T2 has stopped */
2095 /* Free up any link layer users */
2096 mutex_lock(&gsm->mutex);
2097 for (i = 0; i < NUM_DLCI; i++)
2099 gsm_dlci_release(gsm->dlci[i]);
2100 mutex_unlock(&gsm->mutex);
2101 /* Now wipe the queues */
2102 tty_ldisc_flush(gsm->tty);
2103 list_for_each_entry_safe(txq, ntxq, &gsm->tx_list, list)
2105 INIT_LIST_HEAD(&gsm->tx_list);
2109 * gsm_activate_mux - generic GSM setup
2112 * Set up the bits of the mux which are the same for all framing
2113 * protocols. Add the mux to the mux table so it can be opened and
2114 * finally kick off connecting to DLCI 0 on the modem.
2117 static int gsm_activate_mux(struct gsm_mux *gsm)
2119 struct gsm_dlci *dlci;
2122 timer_setup(&gsm->t2_timer, gsm_control_retransmit, 0);
2123 init_waitqueue_head(&gsm->event);
2124 spin_lock_init(&gsm->control_lock);
2125 spin_lock_init(&gsm->tx_lock);
2127 if (gsm->encoding == 0)
2128 gsm->receive = gsm0_receive;
2130 gsm->receive = gsm1_receive;
2131 gsm->error = gsm_error;
2133 spin_lock(&gsm_mux_lock);
2134 for (i = 0; i < MAX_MUX; i++) {
2135 if (gsm_mux[i] == NULL) {
2141 spin_unlock(&gsm_mux_lock);
2145 dlci = gsm_dlci_alloc(gsm, 0);
2148 gsm->dead = 0; /* Tty opens are now permissible */
2153 * gsm_free_mux - free up a mux
2156 * Dispose of allocated resources for a dead mux
2158 static void gsm_free_mux(struct gsm_mux *gsm)
2160 kfree(gsm->txframe);
2166 * gsm_free_muxr - free up a mux
2169 * Dispose of allocated resources for a dead mux
2171 static void gsm_free_muxr(struct kref *ref)
2173 struct gsm_mux *gsm = container_of(ref, struct gsm_mux, ref);
2177 static inline void mux_get(struct gsm_mux *gsm)
2179 kref_get(&gsm->ref);
2182 static inline void mux_put(struct gsm_mux *gsm)
2184 kref_put(&gsm->ref, gsm_free_muxr);
2188 * gsm_alloc_mux - allocate a mux
2190 * Creates a new mux ready for activation.
2193 static struct gsm_mux *gsm_alloc_mux(void)
2195 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2198 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2199 if (gsm->buf == NULL) {
2203 gsm->txframe = kmalloc(2 * (MAX_MTU + PROT_OVERHEAD - 1), GFP_KERNEL);
2204 if (gsm->txframe == NULL) {
2209 spin_lock_init(&gsm->lock);
2210 mutex_init(&gsm->mutex);
2211 kref_init(&gsm->ref);
2212 INIT_LIST_HEAD(&gsm->tx_list);
2220 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
2222 gsm->dead = 1; /* Avoid early tty opens */
2228 * gsmld_output - write to link
2230 * @data: bytes to output
2233 * Write a block of data from the GSM mux to the data channel. This
2234 * will eventually be serialized from above but at the moment isn't.
2237 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2239 if (tty_write_room(gsm->tty) < len) {
2240 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2244 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET,
2246 gsm->tty->ops->write(gsm->tty, data, len);
2251 * gsmld_attach_gsm - mode set up
2252 * @tty: our tty structure
2255 * Set up the MUX for basic mode and commence connecting to the
2256 * modem. Currently called from the line discipline set up but
2257 * will need moving to an ioctl path.
2260 static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2264 gsm->tty = tty_kref_get(tty);
2265 gsm->output = gsmld_output;
2266 ret = gsm_activate_mux(gsm);
2268 tty_kref_put(gsm->tty);
2270 /* Don't register device 0 - this is the control channel and not
2271 a usable tty interface */
2272 base = gsm->num << 6; /* Base for this MUX */
2273 for (i = 1; i < NUM_DLCI; i++)
2274 tty_register_device(gsm_tty_driver, base + i, NULL);
2281 * gsmld_detach_gsm - stop doing 0710 mux
2282 * @tty: tty attached to the mux
2285 * Shutdown and then clean up the resources used by the line discipline
2288 static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2291 int base = gsm->num << 6; /* Base for this MUX */
2293 WARN_ON(tty != gsm->tty);
2294 for (i = 1; i < NUM_DLCI; i++)
2295 tty_unregister_device(gsm_tty_driver, base + i);
2296 gsm_cleanup_mux(gsm);
2297 tty_kref_put(gsm->tty);
2301 static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2302 char *fp, int count)
2304 struct gsm_mux *gsm = tty->disc_data;
2305 const unsigned char *dp;
2308 char flags = TTY_NORMAL;
2311 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET,
2314 for (i = count, dp = cp, f = fp; i; i--, dp++) {
2319 gsm->receive(gsm, *dp);
2325 gsm->error(gsm, *dp, flags);
2328 WARN_ONCE(1, "%s: unknown flag %d\n",
2329 tty_name(tty), flags);
2333 /* FASYNC if needed ? */
2334 /* If clogged call tty_throttle(tty); */
2338 * gsmld_flush_buffer - clean input queue
2339 * @tty: terminal device
2341 * Flush the input buffer. Called when the line discipline is
2342 * being closed, when the tty layer wants the buffer flushed (eg
2346 static void gsmld_flush_buffer(struct tty_struct *tty)
2351 * gsmld_close - close the ldisc for this tty
2354 * Called from the terminal layer when this line discipline is
2355 * being shut down, either because of a close or becsuse of a
2356 * discipline change. The function will not be called while other
2357 * ldisc methods are in progress.
2360 static void gsmld_close(struct tty_struct *tty)
2362 struct gsm_mux *gsm = tty->disc_data;
2364 gsmld_detach_gsm(tty, gsm);
2366 gsmld_flush_buffer(tty);
2367 /* Do other clean up here */
2372 * gsmld_open - open an ldisc
2373 * @tty: terminal to open
2375 * Called when this line discipline is being attached to the
2376 * terminal device. Can sleep. Called serialized so that no
2377 * other events will occur in parallel. No further open will occur
2381 static int gsmld_open(struct tty_struct *tty)
2383 struct gsm_mux *gsm;
2386 if (tty->ops->write == NULL)
2389 /* Attach our ldisc data */
2390 gsm = gsm_alloc_mux();
2394 tty->disc_data = gsm;
2395 tty->receive_room = 65536;
2397 /* Attach the initial passive connection */
2400 ret = gsmld_attach_gsm(tty, gsm);
2402 gsm_cleanup_mux(gsm);
2409 * gsmld_write_wakeup - asynchronous I/O notifier
2412 * Required for the ptys, serial driver etc. since processes
2413 * that attach themselves to the master and rely on ASYNC
2414 * IO must be woken up
2417 static void gsmld_write_wakeup(struct tty_struct *tty)
2419 struct gsm_mux *gsm = tty->disc_data;
2420 unsigned long flags;
2423 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2424 spin_lock_irqsave(&gsm->tx_lock, flags);
2425 gsm_data_kick(gsm, NULL);
2426 if (gsm->tx_bytes < TX_THRESH_LO) {
2427 gsm_dlci_data_sweep(gsm);
2429 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2433 * gsmld_read - read function for tty
2435 * @file: file object
2436 * @buf: userspace buffer pointer
2439 * Perform reads for the line discipline. We are guaranteed that the
2440 * line discipline will not be closed under us but we may get multiple
2441 * parallel readers and must handle this ourselves. We may also get
2442 * a hangup. Always called in user context, may sleep.
2444 * This code must be sure never to sleep through a hangup.
2447 static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2448 unsigned char __user *buf, size_t nr)
2454 * gsmld_write - write function for tty
2456 * @file: file object
2457 * @buf: userspace buffer pointer
2460 * Called when the owner of the device wants to send a frame
2461 * itself (or some other control data). The data is transferred
2462 * as-is and must be properly framed and checksummed as appropriate
2463 * by userspace. Frames are either sent whole or not at all as this
2464 * avoids pain user side.
2467 static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2468 const unsigned char *buf, size_t nr)
2470 int space = tty_write_room(tty);
2472 return tty->ops->write(tty, buf, nr);
2473 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2478 * gsmld_poll - poll method for N_GSM0710
2479 * @tty: terminal device
2480 * @file: file accessing it
2483 * Called when the line discipline is asked to poll() for data or
2484 * for special events. This code is not serialized with respect to
2485 * other events save open/close.
2487 * This code must be sure never to sleep through a hangup.
2488 * Called without the kernel lock held - fine
2491 static __poll_t gsmld_poll(struct tty_struct *tty, struct file *file,
2495 struct gsm_mux *gsm = tty->disc_data;
2497 poll_wait(file, &tty->read_wait, wait);
2498 poll_wait(file, &tty->write_wait, wait);
2499 if (tty_hung_up_p(file))
2501 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2502 mask |= EPOLLOUT | EPOLLWRNORM;
2508 static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2509 struct gsm_config *c)
2512 int need_restart = 0;
2514 /* Stuff we don't support yet - UI or I frame transport, windowing */
2515 if ((c->adaption != 1 && c->adaption != 2) || c->k)
2517 /* Check the MRU/MTU range looks sane */
2518 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2522 if (c->encapsulation > 1) /* Basic, advanced, no I */
2524 if (c->initiator > 1)
2526 if (c->i == 0 || c->i > 2) /* UIH and UI only */
2529 * See what is needed for reconfiguration
2533 if (c->t1 != 0 && c->t1 != gsm->t1)
2535 if (c->t2 != 0 && c->t2 != gsm->t2)
2537 if (c->encapsulation != gsm->encoding)
2539 if (c->adaption != gsm->adaption)
2542 if (c->initiator != gsm->initiator)
2544 if (c->mru != gsm->mru)
2546 if (c->mtu != gsm->mtu)
2550 * Close down what is needed, restart and initiate the new
2554 if (need_close || need_restart) {
2557 ret = gsm_disconnect(gsm);
2563 gsm_cleanup_mux(gsm);
2565 gsm->initiator = c->initiator;
2568 gsm->encoding = c->encapsulation;
2569 gsm->adaption = c->adaption;
2582 /* FIXME: We need to separate activation/deactivation from adding
2583 and removing from the mux array */
2585 gsm_activate_mux(gsm);
2586 if (gsm->initiator && need_close)
2587 gsm_dlci_begin_open(gsm->dlci[0]);
2591 static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2592 unsigned int cmd, unsigned long arg)
2594 struct gsm_config c;
2595 struct gsm_mux *gsm = tty->disc_data;
2598 case GSMIOC_GETCONF:
2599 memset(&c, 0, sizeof(c));
2600 c.adaption = gsm->adaption;
2601 c.encapsulation = gsm->encoding;
2602 c.initiator = gsm->initiator;
2605 c.t3 = 0; /* Not supported */
2607 if (gsm->ftype == UIH)
2611 pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
2615 if (copy_to_user((void *)arg, &c, sizeof(c)))
2618 case GSMIOC_SETCONF:
2619 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2621 return gsmld_config(tty, gsm, &c);
2623 return n_tty_ioctl_helper(tty, file, cmd, arg);
2627 #ifdef CONFIG_COMPAT
2628 static long gsmld_compat_ioctl(struct tty_struct *tty, struct file *file,
2629 unsigned int cmd, unsigned long arg)
2631 return gsmld_ioctl(tty, file, cmd, arg);
2640 static int gsm_mux_net_open(struct net_device *net)
2642 pr_debug("%s called\n", __func__);
2643 netif_start_queue(net);
2647 static int gsm_mux_net_close(struct net_device *net)
2649 netif_stop_queue(net);
2653 static void dlci_net_free(struct gsm_dlci *dlci)
2659 dlci->adaption = dlci->prev_adaption;
2660 dlci->data = dlci->prev_data;
2661 free_netdev(dlci->net);
2664 static void net_free(struct kref *ref)
2666 struct gsm_mux_net *mux_net;
2667 struct gsm_dlci *dlci;
2669 mux_net = container_of(ref, struct gsm_mux_net, ref);
2670 dlci = mux_net->dlci;
2673 unregister_netdev(dlci->net);
2674 dlci_net_free(dlci);
2678 static inline void muxnet_get(struct gsm_mux_net *mux_net)
2680 kref_get(&mux_net->ref);
2683 static inline void muxnet_put(struct gsm_mux_net *mux_net)
2685 kref_put(&mux_net->ref, net_free);
2688 static netdev_tx_t gsm_mux_net_start_xmit(struct sk_buff *skb,
2689 struct net_device *net)
2691 struct gsm_mux_net *mux_net = netdev_priv(net);
2692 struct gsm_dlci *dlci = mux_net->dlci;
2693 muxnet_get(mux_net);
2695 skb_queue_head(&dlci->skb_list, skb);
2696 net->stats.tx_packets++;
2697 net->stats.tx_bytes += skb->len;
2698 gsm_dlci_data_kick(dlci);
2699 /* And tell the kernel when the last transmit started. */
2700 netif_trans_update(net);
2701 muxnet_put(mux_net);
2702 return NETDEV_TX_OK;
2705 /* called when a packet did not ack after watchdogtimeout */
2706 static void gsm_mux_net_tx_timeout(struct net_device *net)
2708 /* Tell syslog we are hosed. */
2709 dev_dbg(&net->dev, "Tx timed out.\n");
2711 /* Update statistics */
2712 net->stats.tx_errors++;
2715 static void gsm_mux_rx_netchar(struct gsm_dlci *dlci,
2716 unsigned char *in_buf, int size)
2718 struct net_device *net = dlci->net;
2719 struct sk_buff *skb;
2720 struct gsm_mux_net *mux_net = netdev_priv(net);
2721 muxnet_get(mux_net);
2723 /* Allocate an sk_buff */
2724 skb = dev_alloc_skb(size + NET_IP_ALIGN);
2726 /* We got no receive buffer. */
2727 net->stats.rx_dropped++;
2728 muxnet_put(mux_net);
2731 skb_reserve(skb, NET_IP_ALIGN);
2732 skb_put_data(skb, in_buf, size);
2735 skb->protocol = htons(ETH_P_IP);
2737 /* Ship it off to the kernel */
2740 /* update out statistics */
2741 net->stats.rx_packets++;
2742 net->stats.rx_bytes += size;
2743 muxnet_put(mux_net);
2747 static void gsm_mux_net_init(struct net_device *net)
2749 static const struct net_device_ops gsm_netdev_ops = {
2750 .ndo_open = gsm_mux_net_open,
2751 .ndo_stop = gsm_mux_net_close,
2752 .ndo_start_xmit = gsm_mux_net_start_xmit,
2753 .ndo_tx_timeout = gsm_mux_net_tx_timeout,
2756 net->netdev_ops = &gsm_netdev_ops;
2758 /* fill in the other fields */
2759 net->watchdog_timeo = GSM_NET_TX_TIMEOUT;
2760 net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
2761 net->type = ARPHRD_NONE;
2762 net->tx_queue_len = 10;
2766 /* caller holds the dlci mutex */
2767 static void gsm_destroy_network(struct gsm_dlci *dlci)
2769 struct gsm_mux_net *mux_net;
2771 pr_debug("destroy network interface");
2774 mux_net = netdev_priv(dlci->net);
2775 muxnet_put(mux_net);
2779 /* caller holds the dlci mutex */
2780 static int gsm_create_network(struct gsm_dlci *dlci, struct gsm_netconfig *nc)
2784 struct net_device *net;
2785 struct gsm_mux_net *mux_net;
2787 if (!capable(CAP_NET_ADMIN))
2790 /* Already in a non tty mode */
2791 if (dlci->adaption > 2)
2794 if (nc->protocol != htons(ETH_P_IP))
2795 return -EPROTONOSUPPORT;
2797 if (nc->adaption != 3 && nc->adaption != 4)
2798 return -EPROTONOSUPPORT;
2800 pr_debug("create network interface");
2803 if (nc->if_name[0] != '\0')
2804 netname = nc->if_name;
2805 net = alloc_netdev(sizeof(struct gsm_mux_net), netname,
2806 NET_NAME_UNKNOWN, gsm_mux_net_init);
2808 pr_err("alloc_netdev failed");
2811 net->mtu = dlci->gsm->mtu;
2813 net->max_mtu = dlci->gsm->mtu;
2814 mux_net = netdev_priv(net);
2815 mux_net->dlci = dlci;
2816 kref_init(&mux_net->ref);
2817 strncpy(nc->if_name, net->name, IFNAMSIZ); /* return net name */
2819 /* reconfigure dlci for network */
2820 dlci->prev_adaption = dlci->adaption;
2821 dlci->prev_data = dlci->data;
2822 dlci->adaption = nc->adaption;
2823 dlci->data = gsm_mux_rx_netchar;
2826 pr_debug("register netdev");
2827 retval = register_netdev(net);
2829 pr_err("network register fail %d\n", retval);
2830 dlci_net_free(dlci);
2833 return net->ifindex; /* return network index */
2836 /* Line discipline for real tty */
2837 static struct tty_ldisc_ops tty_ldisc_packet = {
2838 .owner = THIS_MODULE,
2839 .magic = TTY_LDISC_MAGIC,
2842 .close = gsmld_close,
2843 .flush_buffer = gsmld_flush_buffer,
2845 .write = gsmld_write,
2846 #ifdef CONFIG_COMPAT
2847 .compat_ioctl = gsmld_compat_ioctl,
2849 .ioctl = gsmld_ioctl,
2851 .receive_buf = gsmld_receive_buf,
2852 .write_wakeup = gsmld_write_wakeup
2861 static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2864 struct gsm_control *ctrl;
2867 modembits[0] = (dlci->addr << 2) | 2 | EA; /* DLCI, Valid, EA */
2868 modembits[1] = (gsm_encode_modem(dlci) << 1) | EA;
2870 modembits[2] = (brk << 4) | 2 | EA; /* Length, Break, EA */
2873 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len);
2876 return gsm_control_wait(dlci->gsm, ctrl);
2879 static int gsm_carrier_raised(struct tty_port *port)
2881 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2882 struct gsm_mux *gsm = dlci->gsm;
2884 /* Not yet open so no carrier info */
2885 if (dlci->state != DLCI_OPEN)
2891 * Basic mode with control channel in ADM mode may not respond
2892 * to CMD_MSC at all and modem_rx is empty.
2894 if (gsm->encoding == 0 && gsm->dlci[0]->mode == DLCI_MODE_ADM &&
2898 return dlci->modem_rx & TIOCM_CD;
2901 static void gsm_dtr_rts(struct tty_port *port, int onoff)
2903 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2904 unsigned int modem_tx = dlci->modem_tx;
2906 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2908 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2909 if (modem_tx != dlci->modem_tx) {
2910 dlci->modem_tx = modem_tx;
2911 gsmtty_modem_update(dlci, 0);
2915 static const struct tty_port_operations gsm_port_ops = {
2916 .carrier_raised = gsm_carrier_raised,
2917 .dtr_rts = gsm_dtr_rts,
2918 .destruct = gsm_dlci_free,
2921 static int gsmtty_install(struct tty_driver *driver, struct tty_struct *tty)
2923 struct gsm_mux *gsm;
2924 struct gsm_dlci *dlci;
2925 unsigned int line = tty->index;
2926 unsigned int mux = line >> 6;
2934 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2935 if (gsm_mux[mux] == NULL)
2937 if (line == 0 || line > 61) /* 62/63 reserved */
2942 /* If DLCI 0 is not yet fully open return an error.
2943 This is ok from a locking
2944 perspective as we don't have to worry about this
2946 mutex_lock(&gsm->mutex);
2947 if (gsm->dlci[0] && gsm->dlci[0]->state != DLCI_OPEN) {
2948 mutex_unlock(&gsm->mutex);
2951 dlci = gsm->dlci[line];
2954 dlci = gsm_dlci_alloc(gsm, line);
2957 mutex_unlock(&gsm->mutex);
2960 ret = tty_port_install(&dlci->port, driver, tty);
2964 mutex_unlock(&gsm->mutex);
2969 dlci_get(gsm->dlci[0]);
2971 tty->driver_data = dlci;
2972 mutex_unlock(&gsm->mutex);
2977 static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2979 struct gsm_dlci *dlci = tty->driver_data;
2980 struct tty_port *port = &dlci->port;
2983 tty_port_tty_set(port, tty);
2986 /* We could in theory open and close before we wait - eg if we get
2987 a DM straight back. This is ok as that will have caused a hangup */
2988 tty_port_set_initialized(port, 1);
2989 /* Start sending off SABM messages */
2990 gsm_dlci_begin_open(dlci);
2991 /* And wait for virtual carrier */
2992 return tty_port_block_til_ready(port, tty, filp);
2995 static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2997 struct gsm_dlci *dlci = tty->driver_data;
3001 if (dlci->state == DLCI_CLOSED)
3003 mutex_lock(&dlci->mutex);
3004 gsm_destroy_network(dlci);
3005 mutex_unlock(&dlci->mutex);
3006 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
3008 gsm_dlci_begin_close(dlci);
3009 if (tty_port_initialized(&dlci->port) && C_HUPCL(tty))
3010 tty_port_lower_dtr_rts(&dlci->port);
3011 tty_port_close_end(&dlci->port, tty);
3012 tty_port_tty_set(&dlci->port, NULL);
3016 static void gsmtty_hangup(struct tty_struct *tty)
3018 struct gsm_dlci *dlci = tty->driver_data;
3019 if (dlci->state == DLCI_CLOSED)
3021 tty_port_hangup(&dlci->port);
3022 gsm_dlci_begin_close(dlci);
3025 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
3029 struct gsm_dlci *dlci = tty->driver_data;
3030 if (dlci->state == DLCI_CLOSED)
3032 /* Stuff the bytes into the fifo queue */
3033 sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
3034 /* Need to kick the channel */
3035 gsm_dlci_data_kick(dlci);
3039 static int gsmtty_write_room(struct tty_struct *tty)
3041 struct gsm_dlci *dlci = tty->driver_data;
3042 if (dlci->state == DLCI_CLOSED)
3044 return TX_SIZE - kfifo_len(dlci->fifo);
3047 static int gsmtty_chars_in_buffer(struct tty_struct *tty)
3049 struct gsm_dlci *dlci = tty->driver_data;
3050 if (dlci->state == DLCI_CLOSED)
3052 return kfifo_len(dlci->fifo);
3055 static void gsmtty_flush_buffer(struct tty_struct *tty)
3057 struct gsm_dlci *dlci = tty->driver_data;
3058 if (dlci->state == DLCI_CLOSED)
3060 /* Caution needed: If we implement reliable transport classes
3061 then the data being transmitted can't simply be junked once
3062 it has first hit the stack. Until then we can just blow it
3064 kfifo_reset(dlci->fifo);
3065 /* Need to unhook this DLCI from the transmit queue logic */
3068 static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
3070 /* The FIFO handles the queue so the kernel will do the right
3071 thing waiting on chars_in_buffer before calling us. No work
3075 static int gsmtty_tiocmget(struct tty_struct *tty)
3077 struct gsm_dlci *dlci = tty->driver_data;
3078 if (dlci->state == DLCI_CLOSED)
3080 return dlci->modem_rx;
3083 static int gsmtty_tiocmset(struct tty_struct *tty,
3084 unsigned int set, unsigned int clear)
3086 struct gsm_dlci *dlci = tty->driver_data;
3087 unsigned int modem_tx = dlci->modem_tx;
3089 if (dlci->state == DLCI_CLOSED)
3094 if (modem_tx != dlci->modem_tx) {
3095 dlci->modem_tx = modem_tx;
3096 return gsmtty_modem_update(dlci, 0);
3102 static int gsmtty_ioctl(struct tty_struct *tty,
3103 unsigned int cmd, unsigned long arg)
3105 struct gsm_dlci *dlci = tty->driver_data;
3106 struct gsm_netconfig nc;
3109 if (dlci->state == DLCI_CLOSED)
3112 case GSMIOC_ENABLE_NET:
3113 if (copy_from_user(&nc, (void __user *)arg, sizeof(nc)))
3115 nc.if_name[IFNAMSIZ-1] = '\0';
3116 /* return net interface index or error code */
3117 mutex_lock(&dlci->mutex);
3118 index = gsm_create_network(dlci, &nc);
3119 mutex_unlock(&dlci->mutex);
3120 if (copy_to_user((void __user *)arg, &nc, sizeof(nc)))
3123 case GSMIOC_DISABLE_NET:
3124 if (!capable(CAP_NET_ADMIN))
3126 mutex_lock(&dlci->mutex);
3127 gsm_destroy_network(dlci);
3128 mutex_unlock(&dlci->mutex);
3131 return -ENOIOCTLCMD;
3135 static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
3137 struct gsm_dlci *dlci = tty->driver_data;
3138 if (dlci->state == DLCI_CLOSED)
3140 /* For the moment its fixed. In actual fact the speed information
3141 for the virtual channel can be propogated in both directions by
3142 the RPN control message. This however rapidly gets nasty as we
3143 then have to remap modem signals each way according to whether
3144 our virtual cable is null modem etc .. */
3145 tty_termios_copy_hw(&tty->termios, old);
3148 static void gsmtty_throttle(struct tty_struct *tty)
3150 struct gsm_dlci *dlci = tty->driver_data;
3151 if (dlci->state == DLCI_CLOSED)
3154 dlci->modem_tx &= ~TIOCM_DTR;
3155 dlci->throttled = 1;
3156 /* Send an MSC with DTR cleared */
3157 gsmtty_modem_update(dlci, 0);
3160 static void gsmtty_unthrottle(struct tty_struct *tty)
3162 struct gsm_dlci *dlci = tty->driver_data;
3163 if (dlci->state == DLCI_CLOSED)
3166 dlci->modem_tx |= TIOCM_DTR;
3167 dlci->throttled = 0;
3168 /* Send an MSC with DTR set */
3169 gsmtty_modem_update(dlci, 0);
3172 static int gsmtty_break_ctl(struct tty_struct *tty, int state)
3174 struct gsm_dlci *dlci = tty->driver_data;
3175 int encode = 0; /* Off */
3176 if (dlci->state == DLCI_CLOSED)
3179 if (state == -1) /* "On indefinitely" - we can't encode this
3182 else if (state > 0) {
3183 encode = state / 200; /* mS to encoding */
3185 encode = 0x0F; /* Best effort */
3187 return gsmtty_modem_update(dlci, encode);
3190 static void gsmtty_cleanup(struct tty_struct *tty)
3192 struct gsm_dlci *dlci = tty->driver_data;
3193 struct gsm_mux *gsm = dlci->gsm;
3196 dlci_put(gsm->dlci[0]);
3200 /* Virtual ttys for the demux */
3201 static const struct tty_operations gsmtty_ops = {
3202 .install = gsmtty_install,
3203 .open = gsmtty_open,
3204 .close = gsmtty_close,
3205 .write = gsmtty_write,
3206 .write_room = gsmtty_write_room,
3207 .chars_in_buffer = gsmtty_chars_in_buffer,
3208 .flush_buffer = gsmtty_flush_buffer,
3209 .ioctl = gsmtty_ioctl,
3210 .throttle = gsmtty_throttle,
3211 .unthrottle = gsmtty_unthrottle,
3212 .set_termios = gsmtty_set_termios,
3213 .hangup = gsmtty_hangup,
3214 .wait_until_sent = gsmtty_wait_until_sent,
3215 .tiocmget = gsmtty_tiocmget,
3216 .tiocmset = gsmtty_tiocmset,
3217 .break_ctl = gsmtty_break_ctl,
3218 .cleanup = gsmtty_cleanup,
3223 static int __init gsm_init(void)
3225 /* Fill in our line protocol discipline, and register it */
3226 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
3228 pr_err("n_gsm: can't register line discipline (err = %d)\n",
3233 gsm_tty_driver = alloc_tty_driver(256);
3234 if (!gsm_tty_driver) {
3235 tty_unregister_ldisc(N_GSM0710);
3236 pr_err("gsm_init: tty allocation failed.\n");
3239 gsm_tty_driver->driver_name = "gsmtty";
3240 gsm_tty_driver->name = "gsmtty";
3241 gsm_tty_driver->major = 0; /* Dynamic */
3242 gsm_tty_driver->minor_start = 0;
3243 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
3244 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
3245 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
3246 | TTY_DRIVER_HARDWARE_BREAK;
3247 gsm_tty_driver->init_termios = tty_std_termios;
3249 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
3250 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
3252 spin_lock_init(&gsm_mux_lock);
3254 if (tty_register_driver(gsm_tty_driver)) {
3255 put_tty_driver(gsm_tty_driver);
3256 tty_unregister_ldisc(N_GSM0710);
3257 pr_err("gsm_init: tty registration failed.\n");
3260 pr_debug("gsm_init: loaded as %d,%d.\n",
3261 gsm_tty_driver->major, gsm_tty_driver->minor_start);
3265 static void __exit gsm_exit(void)
3267 int status = tty_unregister_ldisc(N_GSM0710);
3269 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
3271 tty_unregister_driver(gsm_tty_driver);
3272 put_tty_driver(gsm_tty_driver);
3275 module_init(gsm_init);
3276 module_exit(gsm_exit);
3279 MODULE_LICENSE("GPL");
3280 MODULE_ALIAS_LDISC(N_GSM0710);