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 ?
24 * Improve the tx engine
25 * Resolve tx side locking by adding a queue_head and routing
26 * all control traffic via it
27 * General tidy/document
28 * Review the locking/move to refcounts more (mux now moved to an
29 * alloc/free model ready)
30 * Use newest tty open/close port helpers and install hooks
31 * What to do about power functions ?
32 * Termios setting and negotiation
33 * Do we need a 'which mux are you' ioctl to correlate mux and tty sets
37 #include <linux/types.h>
38 #include <linux/major.h>
39 #include <linux/errno.h>
40 #include <linux/signal.h>
41 #include <linux/fcntl.h>
42 #include <linux/sched.h>
43 #include <linux/interrupt.h>
44 #include <linux/tty.h>
45 #include <linux/ctype.h>
47 #include <linux/string.h>
48 #include <linux/slab.h>
49 #include <linux/poll.h>
50 #include <linux/bitops.h>
51 #include <linux/file.h>
52 #include <linux/uaccess.h>
53 #include <linux/module.h>
54 #include <linux/timer.h>
55 #include <linux/tty_flip.h>
56 #include <linux/tty_driver.h>
57 #include <linux/serial.h>
58 #include <linux/kfifo.h>
59 #include <linux/skbuff.h>
62 #include <linux/netdevice.h>
63 #include <linux/etherdevice.h>
64 #include <linux/gsmmux.h>
67 module_param(debug, int, 0600);
69 /* Defaults: these are from the specification */
71 #define T1 10 /* 100mS */
72 #define T2 34 /* 333mS */
73 #define N2 3 /* Retry 3 times */
75 /* Use long timers for testing at low speed with debug on */
82 * Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte
83 * limits so this is plenty
87 #define GSM_NET_TX_TIMEOUT (HZ*10)
90 * struct gsm_mux_net - network interface
91 * @struct gsm_dlci* dlci
92 * @struct net_device_stats stats;
94 * Created when net interface is initialized.
98 struct gsm_dlci *dlci;
99 struct net_device_stats stats;
102 #define STATS(net) (((struct gsm_mux_net *)netdev_priv(net))->stats)
105 * Each block of data we have queued to go out is in the form of
106 * a gsm_msg which holds everything we need in a link layer independent
111 struct list_head list;
112 u8 addr; /* DLCI address + flags */
113 u8 ctrl; /* Control byte + flags */
114 unsigned int len; /* Length of data block (can be zero) */
115 unsigned char *data; /* Points into buffer but not at the start */
116 unsigned char buffer[0];
120 * Each active data link has a gsm_dlci structure associated which ties
121 * the link layer to an optional tty (if the tty side is open). To avoid
122 * complexity right now these are only ever freed up when the mux is
125 * At the moment we don't free DLCI objects until the mux is torn down
126 * this avoid object life time issues but might be worth review later.
133 #define DLCI_CLOSED 0
134 #define DLCI_OPENING 1 /* Sending SABM not seen UA */
135 #define DLCI_OPEN 2 /* SABM/UA complete */
136 #define DLCI_CLOSING 3 /* Sending DISC not seen UA/DM */
137 struct kref ref; /* freed from port or mux close */
141 spinlock_t lock; /* Protects the internal state */
142 struct timer_list t1; /* Retransmit timer for SABM and UA */
144 /* Uplink tty if active */
145 struct tty_port port; /* The tty bound to this DLCI if there is one */
146 struct kfifo *fifo; /* Queue fifo for the DLCI */
147 struct kfifo _fifo; /* For new fifo API porting only */
148 int adaption; /* Adaption layer in use */
150 u32 modem_rx; /* Our incoming virtual modem lines */
151 u32 modem_tx; /* Our outgoing modem lines */
152 int dead; /* Refuse re-open */
154 int throttled; /* Private copy of throttle state */
155 int constipated; /* Throttle status for outgoing */
157 struct sk_buff *skb; /* Frame being sent */
158 struct sk_buff_head skb_list; /* Queued frames */
159 /* Data handling callback */
160 void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
161 void (*prev_data)(struct gsm_dlci *dlci, u8 *data, int len);
162 struct net_device *net; /* network interface, if created */
165 /* DLCI 0, 62/63 are special or reseved see gsmtty_open */
170 * DLCI 0 is used to pass control blocks out of band of the data
171 * flow (and with a higher link priority). One command can be outstanding
172 * at a time and we use this structure to manage them. They are created
173 * and destroyed by the user context, and updated by the receive paths
178 u8 cmd; /* Command we are issuing */
179 u8 *data; /* Data for the command in case we retransmit */
180 int len; /* Length of block for retransmission */
181 int done; /* Done flag */
182 int error; /* Error if any */
186 * Each GSM mux we have is represented by this structure. If we are
187 * operating as an ldisc then we use this structure as our ldisc
188 * state. We need to sort out lifetimes and locking with respect
189 * to the gsm mux array. For now we don't free DLCI objects that
190 * have been instantiated until the mux itself is terminated.
192 * To consider further: tty open versus mux shutdown.
196 struct tty_struct *tty; /* The tty our ldisc is bound to */
201 /* Events on the GSM channel */
202 wait_queue_head_t event;
204 /* Bits for GSM mode decoding */
211 #define GSM_ADDRESS 2
212 #define GSM_CONTROL 3
216 #define GSM_OVERRUN 7
221 unsigned int address;
228 u8 *txframe; /* TX framing buffer */
230 /* Methods for the receiver side */
231 void (*receive)(struct gsm_mux *gsm, u8 ch);
232 void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
233 /* And transmit side */
234 int (*output)(struct gsm_mux *mux, u8 *data, int len);
239 int initiator; /* Did we initiate connection */
240 int dead; /* Has the mux been shut down */
241 struct gsm_dlci *dlci[NUM_DLCI];
242 int constipated; /* Asked by remote to shut up */
245 unsigned int tx_bytes; /* TX data outstanding */
246 #define TX_THRESH_HI 8192
247 #define TX_THRESH_LO 2048
248 struct list_head tx_list; /* Pending data packets */
250 /* Control messages */
251 struct timer_list t2_timer; /* Retransmit timer for commands */
252 int cretries; /* Command retry counter */
253 struct gsm_control *pending_cmd;/* Our current pending command */
254 spinlock_t control_lock; /* Protects the pending command */
257 int adaption; /* 1 or 2 supported */
258 u8 ftype; /* UI or UIH */
259 int t1, t2; /* Timers in 1/100th of a sec */
260 int n2; /* Retry count */
262 /* Statistics (not currently exposed) */
263 unsigned long bad_fcs;
264 unsigned long malformed;
265 unsigned long io_error;
266 unsigned long bad_size;
267 unsigned long unsupported;
272 * Mux objects - needed so that we can translate a tty index into the
273 * relevant mux and DLCI.
276 #define MAX_MUX 4 /* 256 minors */
277 static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */
278 static spinlock_t gsm_mux_lock;
280 static struct tty_driver *gsm_tty_driver;
283 * This section of the driver logic implements the GSM encodings
284 * both the basic and the 'advanced'. Reliable transport is not
292 /* I is special: the rest are ..*/
303 /* Channel commands */
305 #define CMD_TEST 0x11
308 #define CMD_FCOFF 0x31
311 #define CMD_FCON 0x51
316 /* Virtual modem bits */
323 #define GSM0_SOF 0xF9
324 #define GSM1_SOF 0x7E
325 #define GSM1_ESCAPE 0x7D
326 #define GSM1_ESCAPE_BITS 0x20
330 static const struct tty_port_operations gsm_port_ops;
333 * CRC table for GSM 0710
336 static const u8 gsm_fcs8[256] = {
337 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
338 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
339 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
340 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
341 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
342 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
343 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
344 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
345 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
346 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
347 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
348 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
349 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
350 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
351 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
352 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
353 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
354 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
355 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
356 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
357 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
358 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
359 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
360 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
361 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
362 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
363 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
364 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
365 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
366 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
367 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
368 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
371 #define INIT_FCS 0xFF
372 #define GOOD_FCS 0xCF
375 * gsm_fcs_add - update FCS
379 * Update the FCS to include c. Uses the algorithm in the specification
383 static inline u8 gsm_fcs_add(u8 fcs, u8 c)
385 return gsm_fcs8[fcs ^ c];
389 * gsm_fcs_add_block - update FCS for a block
392 * @len: length of buffer
394 * Update the FCS to include c. Uses the algorithm in the specification
398 static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
401 fcs = gsm_fcs8[fcs ^ *c++];
406 * gsm_read_ea - read a byte into an EA
407 * @val: variable holding value
408 * c: byte going into the EA
410 * Processes one byte of an EA. Updates the passed variable
411 * and returns 1 if the EA is now completely read
414 static int gsm_read_ea(unsigned int *val, u8 c)
416 /* Add the next 7 bits into the value */
419 /* Was this the last byte of the EA 1 = yes*/
424 * gsm_encode_modem - encode modem data bits
425 * @dlci: DLCI to encode from
427 * Returns the correct GSM encoded modem status bits (6 bit field) for
428 * the current status of the DLCI and attached tty object
431 static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
434 /* FC is true flow control not modem bits */
437 if (dlci->modem_tx & TIOCM_DTR)
438 modembits |= MDM_RTC;
439 if (dlci->modem_tx & TIOCM_RTS)
440 modembits |= MDM_RTR;
441 if (dlci->modem_tx & TIOCM_RI)
443 if (dlci->modem_tx & TIOCM_CD)
449 * gsm_print_packet - display a frame for debug
450 * @hdr: header to print before decode
451 * @addr: address EA from the frame
452 * @cr: C/R bit from the frame
453 * @control: control including PF bit
454 * @data: following data bytes
455 * @dlen: length of data
457 * Displays a packet in human readable format for debugging purposes. The
458 * style is based on amateur radio LAP-B dump display.
461 static void gsm_print_packet(const char *hdr, int addr, int cr,
462 u8 control, const u8 *data, int dlen)
467 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
469 switch (control & ~PF) {
489 if (!(control & 0x01)) {
490 pr_cont("I N(S)%d N(R)%d",
491 (control & 0x0E) >> 1, (control & 0xE) >> 5);
492 } else switch (control & 0x0F) {
494 pr_cont("RR(%d)", (control & 0xE0) >> 5);
497 pr_cont("RNR(%d)", (control & 0xE0) >> 5);
500 pr_cont("REJ(%d)", (control & 0xE0) >> 5);
503 pr_cont("[%02X]", control);
519 pr_cont("%02X ", *data++);
528 * Link level transmission side
532 * gsm_stuff_packet - bytestuff a packet
535 * @len: length of input
537 * Expand a buffer by bytestuffing it. The worst case size change
538 * is doubling and the caller is responsible for handing out
539 * suitable sized buffers.
542 static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
546 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
547 || *input == XON || *input == XOFF) {
548 *output++ = GSM1_ESCAPE;
549 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
552 *output++ = *input++;
559 * gsm_send - send a control frame
561 * @addr: address for control frame
562 * @cr: command/response bit
563 * @control: control byte including PF bit
565 * Format up and transmit a control frame. These do not go via the
566 * queueing logic as they should be transmitted ahead of data when
569 * FIXME: Lock versus data TX path
572 static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
578 switch (gsm->encoding) {
581 cbuf[1] = (addr << 2) | (cr << 1) | EA;
583 cbuf[3] = EA; /* Length of data = 0 */
584 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
590 /* Control frame + packing (but not frame stuffing) in mode 1 */
591 ibuf[0] = (addr << 2) | (cr << 1) | EA;
593 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
594 /* Stuffing may double the size worst case */
595 len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
596 /* Now add the SOF markers */
598 cbuf[len + 1] = GSM1_SOF;
599 /* FIXME: we can omit the lead one in many cases */
606 gsm->output(gsm, cbuf, len);
607 gsm_print_packet("-->", addr, cr, control, NULL, 0);
611 * gsm_response - send a control response
613 * @addr: address for control frame
614 * @control: control byte including PF bit
616 * Format up and transmit a link level response frame.
619 static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
621 gsm_send(gsm, addr, 0, control);
625 * gsm_command - send a control command
627 * @addr: address for control frame
628 * @control: control byte including PF bit
630 * Format up and transmit a link level command frame.
633 static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
635 gsm_send(gsm, addr, 1, control);
638 /* Data transmission */
640 #define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
643 * gsm_data_alloc - allocate data frame
645 * @addr: DLCI address
646 * @len: length excluding header and FCS
647 * @ctrl: control byte
649 * Allocate a new data buffer for sending frames with data. Space is left
650 * at the front for header bytes but that is treated as an implementation
651 * detail and not for the high level code to use
654 static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
657 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
661 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */
665 INIT_LIST_HEAD(&m->list);
670 * gsm_data_kick - poke the queue
673 * The tty device has called us to indicate that room has appeared in
674 * the transmit queue. Ram more data into the pipe if we have any
675 * If we have been flow-stopped by a CMD_FCOFF, then we can only
676 * send messages on DLCI0 until CMD_FCON
678 * FIXME: lock against link layer control transmissions
681 static void gsm_data_kick(struct gsm_mux *gsm)
683 struct gsm_msg *msg, *nmsg;
687 list_for_each_entry_safe(msg, nmsg, &gsm->tx_list, list) {
688 if (gsm->constipated && msg->addr)
690 if (gsm->encoding != 0) {
691 gsm->txframe[0] = GSM1_SOF;
692 len = gsm_stuff_frame(msg->data,
693 gsm->txframe + 1, msg->len);
694 gsm->txframe[len + 1] = GSM1_SOF;
697 gsm->txframe[0] = GSM0_SOF;
698 memcpy(gsm->txframe + 1 , msg->data, msg->len);
699 gsm->txframe[msg->len + 1] = GSM0_SOF;
704 print_hex_dump_bytes("gsm_data_kick: ",
708 if (gsm->output(gsm, gsm->txframe + skip_sof,
711 /* FIXME: Can eliminate one SOF in many more cases */
712 gsm->tx_bytes -= msg->len;
713 /* For a burst of frames skip the extra SOF within the
717 list_del(&msg->list);
723 * __gsm_data_queue - queue a UI or UIH frame
724 * @dlci: DLCI sending the data
725 * @msg: message queued
727 * Add data to the transmit queue and try and get stuff moving
728 * out of the mux tty if not already doing so. The Caller must hold
732 static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
734 struct gsm_mux *gsm = dlci->gsm;
736 u8 *fcs = dp + msg->len;
738 /* Fill in the header */
739 if (gsm->encoding == 0) {
741 *--dp = (msg->len << 1) | EA;
743 *--dp = (msg->len >> 7); /* bits 7 - 15 */
744 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */
750 *--dp = (msg->addr << 2) | 2 | EA;
752 *--dp = (msg->addr << 2) | EA;
753 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
754 /* Ugly protocol layering violation */
755 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
756 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
759 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
760 msg->data, msg->len);
762 /* Move the header back and adjust the length, also allow for the FCS
763 now tacked on the end */
764 msg->len += (msg->data - dp) + 1;
767 /* Add to the actual output queue */
768 list_add_tail(&msg->list, &gsm->tx_list);
769 gsm->tx_bytes += msg->len;
774 * gsm_data_queue - queue a UI or UIH frame
775 * @dlci: DLCI sending the data
776 * @msg: message queued
778 * Add data to the transmit queue and try and get stuff moving
779 * out of the mux tty if not already doing so. Take the
780 * the gsm tx lock and dlci lock.
783 static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
786 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
787 __gsm_data_queue(dlci, msg);
788 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
792 * gsm_dlci_data_output - try and push data out of a DLCI
794 * @dlci: the DLCI to pull data from
796 * Pull data from a DLCI and send it into the transmit queue if there
797 * is data. Keep to the MRU of the mux. This path handles the usual tty
798 * interface which is a byte stream with optional modem data.
800 * Caller must hold the tx_lock of the mux.
803 static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
807 int len, total_size, size;
808 int h = dlci->adaption - 1;
812 len = kfifo_len(dlci->fifo);
816 /* MTU/MRU count only the data bits */
822 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
823 /* FIXME: need a timer or something to kick this so it can't
824 get stuck with no work outstanding and no buffer free */
828 switch (dlci->adaption) {
829 case 1: /* Unstructured */
831 case 2: /* Unstructed with modem bits. Always one byte as we never
832 send inline break data */
833 *dp++ = gsm_encode_modem(dlci);
836 WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
837 __gsm_data_queue(dlci, msg);
840 /* Bytes of data we used up */
845 * gsm_dlci_data_output_framed - try and push data out of a DLCI
847 * @dlci: the DLCI to pull data from
849 * Pull data from a DLCI and send it into the transmit queue if there
850 * is data. Keep to the MRU of the mux. This path handles framed data
851 * queued as skbuffs to the DLCI.
853 * Caller must hold the tx_lock of the mux.
856 static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
857 struct gsm_dlci *dlci)
862 int last = 0, first = 0;
865 /* One byte per frame is used for B/F flags */
866 if (dlci->adaption == 4)
869 /* dlci->skb is locked by tx_lock */
870 if (dlci->skb == NULL) {
871 dlci->skb = skb_dequeue_tail(&dlci->skb_list);
872 if (dlci->skb == NULL)
876 len = dlci->skb->len + overhead;
878 /* MTU/MRU count only the data bits */
879 if (len > gsm->mtu) {
880 if (dlci->adaption == 3) {
881 /* Over long frame, bin it */
882 dev_kfree_skb_any(dlci->skb);
890 size = len + overhead;
891 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
893 /* FIXME: need a timer or something to kick this so it can't
894 get stuck with no work outstanding and no buffer free */
896 skb_queue_tail(&dlci->skb_list, dlci->skb);
902 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
903 /* Flag byte to carry the start/end info */
904 *dp++ = last << 7 | first << 6 | 1; /* EA */
907 memcpy(dp, dlci->skb->data, len);
908 skb_pull(dlci->skb, len);
909 __gsm_data_queue(dlci, msg);
911 dev_kfree_skb_any(dlci->skb);
918 * gsm_dlci_data_sweep - look for data to send
921 * Sweep the GSM mux channels in priority order looking for ones with
922 * data to send. We could do with optimising this scan a bit. We aim
923 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
924 * TX_THRESH_LO we get called again
926 * FIXME: We should round robin between groups and in theory you can
927 * renegotiate DLCI priorities with optional stuff. Needs optimising.
930 static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
933 /* Priority ordering: We should do priority with RR of the groups */
936 while (i < NUM_DLCI) {
937 struct gsm_dlci *dlci;
939 if (gsm->tx_bytes > TX_THRESH_HI)
942 if (dlci == NULL || dlci->constipated) {
946 if (dlci->adaption < 3 && !dlci->net)
947 len = gsm_dlci_data_output(gsm, dlci);
949 len = gsm_dlci_data_output_framed(gsm, dlci);
952 /* DLCI empty - try the next */
959 * gsm_dlci_data_kick - transmit if possible
960 * @dlci: DLCI to kick
962 * Transmit data from this DLCI if the queue is empty. We can't rely on
963 * a tty wakeup except when we filled the pipe so we need to fire off
964 * new data ourselves in other cases.
967 static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
972 if (dlci->constipated)
975 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
976 /* If we have nothing running then we need to fire up */
977 sweep = (dlci->gsm->tx_bytes < TX_THRESH_LO);
978 if (dlci->gsm->tx_bytes == 0) {
980 gsm_dlci_data_output_framed(dlci->gsm, dlci);
982 gsm_dlci_data_output(dlci->gsm, dlci);
985 gsm_dlci_data_sweep(dlci->gsm);
986 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
990 * Control message processing
995 * gsm_control_reply - send a response frame to a control
997 * @cmd: the command to use
998 * @data: data to follow encoded info
999 * @dlen: length of data
1001 * Encode up and queue a UI/UIH frame containing our response.
1004 static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
1007 struct gsm_msg *msg;
1008 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
1011 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */
1012 msg->data[1] = (dlen << 1) | EA;
1013 memcpy(msg->data + 2, data, dlen);
1014 gsm_data_queue(gsm->dlci[0], msg);
1018 * gsm_process_modem - process received modem status
1019 * @tty: virtual tty bound to the DLCI
1020 * @dlci: DLCI to affect
1021 * @modem: modem bits (full EA)
1023 * Used when a modem control message or line state inline in adaption
1024 * layer 2 is processed. Sort out the local modem state and throttles
1027 static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
1028 u32 modem, int clen)
1034 /* The modem status command can either contain one octet (v.24 signals)
1035 or two octets (v.24 signals + break signals). The length field will
1036 either be 2 or 3 respectively. This is specified in section
1037 5.4.6.3.7 of the 27.010 mux spec. */
1040 modem = modem & 0x7f;
1043 modem = (modem >> 7) & 0x7f;
1046 /* Flow control/ready to communicate */
1047 fc = (modem & MDM_FC) || !(modem & MDM_RTR);
1048 if (fc && !dlci->constipated) {
1049 /* Need to throttle our output on this device */
1050 dlci->constipated = 1;
1051 } else if (!fc && dlci->constipated) {
1052 dlci->constipated = 0;
1053 gsm_dlci_data_kick(dlci);
1056 /* Map modem bits */
1057 if (modem & MDM_RTC)
1058 mlines |= TIOCM_DSR | TIOCM_DTR;
1059 if (modem & MDM_RTR)
1060 mlines |= TIOCM_RTS | TIOCM_CTS;
1066 /* Carrier drop -> hangup */
1068 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1069 if (!(tty->termios->c_cflag & CLOCAL))
1072 tty_insert_flip_char(tty, 0, TTY_BREAK);
1074 dlci->modem_rx = mlines;
1078 * gsm_control_modem - modem status received
1080 * @data: data following command
1081 * @clen: command length
1083 * We have received a modem status control message. This is used by
1084 * the GSM mux protocol to pass virtual modem line status and optionally
1085 * to indicate break signals. Unpack it, convert to Linux representation
1086 * and if need be stuff a break message down the tty.
1089 static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1091 unsigned int addr = 0;
1092 unsigned int modem = 0;
1093 unsigned int brk = 0;
1094 struct gsm_dlci *dlci;
1097 struct tty_struct *tty;
1099 while (gsm_read_ea(&addr, *dp++) == 0) {
1104 /* Must be at least one byte following the EA */
1110 /* Closed port, or invalid ? */
1111 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1113 dlci = gsm->dlci[addr];
1115 while (gsm_read_ea(&modem, *dp++) == 0) {
1122 while (gsm_read_ea(&brk, *dp++) == 0) {
1128 modem |= (brk & 0x7f);
1130 tty = tty_port_tty_get(&dlci->port);
1131 gsm_process_modem(tty, dlci, modem, clen);
1136 gsm_control_reply(gsm, CMD_MSC, data, clen);
1140 * gsm_control_rls - remote line status
1143 * @clen: data length
1145 * The modem sends us a two byte message on the control channel whenever
1146 * it wishes to send us an error state from the virtual link. Stuff
1147 * this into the uplink tty if present
1150 static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1152 struct tty_struct *tty;
1153 unsigned int addr = 0 ;
1158 while (gsm_read_ea(&addr, *dp++) == 0) {
1163 /* Must be at least one byte following ea */
1168 /* Closed port, or invalid ? */
1169 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1173 if ((bits & 1) == 0)
1175 /* See if we have an uplink tty */
1176 tty = tty_port_tty_get(&gsm->dlci[addr]->port);
1180 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1182 tty_insert_flip_char(tty, 0, TTY_PARITY);
1184 tty_insert_flip_char(tty, 0, TTY_FRAME);
1185 tty_flip_buffer_push(tty);
1188 gsm_control_reply(gsm, CMD_RLS, data, clen);
1191 static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1194 * gsm_control_message - DLCI 0 control processing
1196 * @command: the command EA
1197 * @data: data beyond the command/length EAs
1200 * Input processor for control messages from the other end of the link.
1201 * Processes the incoming request and queues a response frame or an
1202 * NSC response if not supported
1205 static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1209 unsigned long flags;
1213 struct gsm_dlci *dlci = gsm->dlci[0];
1214 /* Modem wishes to close down */
1218 gsm_dlci_begin_close(dlci);
1223 /* Modem wishes to test, reply with the data */
1224 gsm_control_reply(gsm, CMD_TEST, data, clen);
1227 /* Modem can accept data again */
1228 gsm->constipated = 0;
1229 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1230 /* Kick the link in case it is idling */
1231 spin_lock_irqsave(&gsm->tx_lock, flags);
1233 spin_unlock_irqrestore(&gsm->tx_lock, flags);
1236 /* Modem wants us to STFU */
1237 gsm->constipated = 1;
1238 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1241 /* Out of band modem line change indicator for a DLCI */
1242 gsm_control_modem(gsm, data, clen);
1245 /* Out of band error reception for a DLCI */
1246 gsm_control_rls(gsm, data, clen);
1249 /* Modem wishes to enter power saving state */
1250 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1252 /* Optional unsupported commands */
1253 case CMD_PN: /* Parameter negotiation */
1254 case CMD_RPN: /* Remote port negotiation */
1255 case CMD_SNC: /* Service negotiation command */
1257 /* Reply to bad commands with an NSC */
1259 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1265 * gsm_control_response - process a response to our control
1267 * @command: the command (response) EA
1268 * @data: data beyond the command/length EA
1271 * Process a response to an outstanding command. We only allow a single
1272 * control message in flight so this is fairly easy. All the clean up
1273 * is done by the caller, we just update the fields, flag it as done
1277 static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1280 struct gsm_control *ctrl;
1281 unsigned long flags;
1283 spin_lock_irqsave(&gsm->control_lock, flags);
1285 ctrl = gsm->pending_cmd;
1286 /* Does the reply match our command */
1288 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1289 /* Our command was replied to, kill the retry timer */
1290 del_timer(&gsm->t2_timer);
1291 gsm->pending_cmd = NULL;
1292 /* Rejected by the other end */
1293 if (command == CMD_NSC)
1294 ctrl->error = -EOPNOTSUPP;
1296 wake_up(&gsm->event);
1298 spin_unlock_irqrestore(&gsm->control_lock, flags);
1302 * gsm_control_transmit - send control packet
1304 * @ctrl: frame to send
1306 * Send out a pending control command (called under control lock)
1309 static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1311 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype);
1314 msg->data[0] = (ctrl->cmd << 1) | 2 | EA; /* command */
1315 memcpy(msg->data + 1, ctrl->data, ctrl->len);
1316 gsm_data_queue(gsm->dlci[0], msg);
1320 * gsm_control_retransmit - retransmit a control frame
1321 * @data: pointer to our gsm object
1323 * Called off the T2 timer expiry in order to retransmit control frames
1324 * that have been lost in the system somewhere. The control_lock protects
1325 * us from colliding with another sender or a receive completion event.
1326 * In that situation the timer may still occur in a small window but
1327 * gsm->pending_cmd will be NULL and we just let the timer expire.
1330 static void gsm_control_retransmit(unsigned long data)
1332 struct gsm_mux *gsm = (struct gsm_mux *)data;
1333 struct gsm_control *ctrl;
1334 unsigned long flags;
1335 spin_lock_irqsave(&gsm->control_lock, flags);
1336 ctrl = gsm->pending_cmd;
1339 if (gsm->cretries == 0) {
1340 gsm->pending_cmd = NULL;
1341 ctrl->error = -ETIMEDOUT;
1343 spin_unlock_irqrestore(&gsm->control_lock, flags);
1344 wake_up(&gsm->event);
1347 gsm_control_transmit(gsm, ctrl);
1348 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1350 spin_unlock_irqrestore(&gsm->control_lock, flags);
1354 * gsm_control_send - send a control frame on DLCI 0
1355 * @gsm: the GSM channel
1356 * @command: command to send including CR bit
1357 * @data: bytes of data (must be kmalloced)
1358 * @len: length of the block to send
1360 * Queue and dispatch a control command. Only one command can be
1361 * active at a time. In theory more can be outstanding but the matching
1362 * gets really complicated so for now stick to one outstanding.
1365 static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1366 unsigned int command, u8 *data, int clen)
1368 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1370 unsigned long flags;
1374 wait_event(gsm->event, gsm->pending_cmd == NULL);
1375 spin_lock_irqsave(&gsm->control_lock, flags);
1376 if (gsm->pending_cmd != NULL) {
1377 spin_unlock_irqrestore(&gsm->control_lock, flags);
1380 ctrl->cmd = command;
1383 gsm->pending_cmd = ctrl;
1384 gsm->cretries = gsm->n2;
1385 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1386 gsm_control_transmit(gsm, ctrl);
1387 spin_unlock_irqrestore(&gsm->control_lock, flags);
1392 * gsm_control_wait - wait for a control to finish
1394 * @control: control we are waiting on
1396 * Waits for the control to complete or time out. Frees any used
1397 * resources and returns 0 for success, or an error if the remote
1398 * rejected or ignored the request.
1401 static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1404 wait_event(gsm->event, control->done == 1);
1405 err = control->error;
1412 * DLCI level handling: Needs krefs
1416 * State transitions and timers
1420 * gsm_dlci_close - a DLCI has closed
1421 * @dlci: DLCI that closed
1423 * Perform processing when moving a DLCI into closed state. If there
1424 * is an attached tty this is hung up
1427 static void gsm_dlci_close(struct gsm_dlci *dlci)
1429 del_timer(&dlci->t1);
1431 pr_debug("DLCI %d goes closed.\n", dlci->addr);
1432 dlci->state = DLCI_CLOSED;
1433 if (dlci->addr != 0) {
1434 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1439 kfifo_reset(dlci->fifo);
1441 dlci->gsm->dead = 1;
1442 wake_up(&dlci->gsm->event);
1443 /* A DLCI 0 close is a MUX termination so we need to kick that
1444 back to userspace somehow */
1448 * gsm_dlci_open - a DLCI has opened
1449 * @dlci: DLCI that opened
1451 * Perform processing when moving a DLCI into open state.
1454 static void gsm_dlci_open(struct gsm_dlci *dlci)
1456 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1458 del_timer(&dlci->t1);
1459 /* This will let a tty open continue */
1460 dlci->state = DLCI_OPEN;
1462 pr_debug("DLCI %d goes open.\n", dlci->addr);
1463 wake_up(&dlci->gsm->event);
1467 * gsm_dlci_t1 - T1 timer expiry
1468 * @dlci: DLCI that opened
1470 * The T1 timer handles retransmits of control frames (essentially of
1471 * SABM and DISC). We resend the command until the retry count runs out
1472 * in which case an opening port goes back to closed and a closing port
1473 * is simply put into closed state (any further frames from the other
1474 * end will get a DM response)
1477 static void gsm_dlci_t1(unsigned long data)
1479 struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1480 struct gsm_mux *gsm = dlci->gsm;
1482 switch (dlci->state) {
1485 if (dlci->retries) {
1486 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1487 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1489 gsm_dlci_close(dlci);
1493 if (dlci->retries) {
1494 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1495 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1497 gsm_dlci_close(dlci);
1503 * gsm_dlci_begin_open - start channel open procedure
1504 * @dlci: DLCI to open
1506 * Commence opening a DLCI from the Linux side. We issue SABM messages
1507 * to the modem which should then reply with a UA, at which point we
1508 * will move into open state. Opening is done asynchronously with retry
1509 * running off timers and the responses.
1512 static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1514 struct gsm_mux *gsm = dlci->gsm;
1515 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1517 dlci->retries = gsm->n2;
1518 dlci->state = DLCI_OPENING;
1519 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1520 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1524 * gsm_dlci_begin_close - start channel open procedure
1525 * @dlci: DLCI to open
1527 * Commence closing a DLCI from the Linux side. We issue DISC messages
1528 * to the modem which should then reply with a UA, at which point we
1529 * will move into closed state. Closing is done asynchronously with retry
1530 * off timers. We may also receive a DM reply from the other end which
1531 * indicates the channel was already closed.
1534 static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1536 struct gsm_mux *gsm = dlci->gsm;
1537 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1539 dlci->retries = gsm->n2;
1540 dlci->state = DLCI_CLOSING;
1541 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1542 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1546 * gsm_dlci_data - data arrived
1548 * @data: block of bytes received
1549 * @len: length of received block
1551 * A UI or UIH frame has arrived which contains data for a channel
1552 * other than the control channel. If the relevant virtual tty is
1553 * open we shovel the bits down it, if not we drop them.
1556 static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int clen)
1559 struct tty_port *port = &dlci->port;
1560 struct tty_struct *tty = tty_port_tty_get(port);
1561 unsigned int modem = 0;
1565 pr_debug("%d bytes for tty %p\n", len, tty);
1567 switch (dlci->adaption) {
1568 /* Unsupported types */
1569 /* Packetised interruptible data */
1572 /* Packetised uininterruptible voice/data */
1575 /* Asynchronous serial with line state in each frame */
1577 while (gsm_read_ea(&modem, *data++) == 0) {
1582 gsm_process_modem(tty, dlci, modem, clen);
1583 /* Line state will go via DLCI 0 controls only */
1586 tty_insert_flip_string(tty, data, len);
1587 tty_flip_buffer_push(tty);
1594 * gsm_dlci_control - data arrived on control channel
1596 * @data: block of bytes received
1597 * @len: length of received block
1599 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1600 * control channel. This should contain a command EA followed by
1601 * control data bytes. The command EA contains a command/response bit
1602 * and we divide up the work accordingly.
1605 static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1607 /* See what command is involved */
1608 unsigned int command = 0;
1610 if (gsm_read_ea(&command, *data++) == 1) {
1613 /* FIXME: this is properly an EA */
1615 /* Malformed command ? */
1619 gsm_control_message(dlci->gsm, command,
1622 gsm_control_response(dlci->gsm, command,
1630 * Allocate/Free DLCI channels
1634 * gsm_dlci_alloc - allocate a DLCI
1636 * @addr: address of the DLCI
1638 * Allocate and install a new DLCI object into the GSM mux.
1640 * FIXME: review locking races
1643 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1645 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1648 spin_lock_init(&dlci->lock);
1649 kref_init(&dlci->ref);
1650 mutex_init(&dlci->mutex);
1651 dlci->fifo = &dlci->_fifo;
1652 if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1657 skb_queue_head_init(&dlci->skb_list);
1658 init_timer(&dlci->t1);
1659 dlci->t1.function = gsm_dlci_t1;
1660 dlci->t1.data = (unsigned long)dlci;
1661 tty_port_init(&dlci->port);
1662 dlci->port.ops = &gsm_port_ops;
1665 dlci->adaption = gsm->adaption;
1666 dlci->state = DLCI_CLOSED;
1668 dlci->data = gsm_dlci_data;
1670 dlci->data = gsm_dlci_command;
1671 gsm->dlci[addr] = dlci;
1676 * gsm_dlci_free - free DLCI
1677 * @dlci: DLCI to free
1683 static void gsm_dlci_free(struct kref *ref)
1685 struct gsm_dlci *dlci = container_of(ref, struct gsm_dlci, ref);
1687 del_timer_sync(&dlci->t1);
1688 dlci->gsm->dlci[dlci->addr] = NULL;
1689 kfifo_free(dlci->fifo);
1690 while ((dlci->skb = skb_dequeue(&dlci->skb_list)))
1691 dev_kfree_skb(dlci->skb);
1695 static inline void dlci_get(struct gsm_dlci *dlci)
1697 kref_get(&dlci->ref);
1700 static inline void dlci_put(struct gsm_dlci *dlci)
1702 kref_put(&dlci->ref, gsm_dlci_free);
1706 * gsm_dlci_release - release DLCI
1707 * @dlci: DLCI to destroy
1709 * Release a DLCI. Actual free is deferred until either
1710 * mux is closed or tty is closed - whichever is last.
1714 static void gsm_dlci_release(struct gsm_dlci *dlci)
1716 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1725 * LAPBish link layer logic
1729 * gsm_queue - a GSM frame is ready to process
1730 * @gsm: pointer to our gsm mux
1732 * At this point in time a frame has arrived and been demangled from
1733 * the line encoding. All the differences between the encodings have
1734 * been handled below us and the frame is unpacked into the structures.
1735 * The fcs holds the header FCS but any data FCS must be added here.
1738 static void gsm_queue(struct gsm_mux *gsm)
1740 struct gsm_dlci *dlci;
1743 /* We have to sneak a look at the packet body to do the FCS.
1744 A somewhat layering violation in the spec */
1746 if ((gsm->control & ~PF) == UI)
1747 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1748 if (gsm->encoding == 0){
1749 /* WARNING: gsm->received_fcs is used for gsm->encoding = 0 only.
1750 In this case it contain the last piece of data
1751 required to generate final CRC */
1752 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1754 if (gsm->fcs != GOOD_FCS) {
1757 pr_debug("BAD FCS %02x\n", gsm->fcs);
1760 address = gsm->address >> 1;
1761 if (address >= NUM_DLCI)
1764 cr = gsm->address & 1; /* C/R bit */
1766 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1768 cr ^= 1 - gsm->initiator; /* Flip so 1 always means command */
1769 dlci = gsm->dlci[address];
1771 switch (gsm->control) {
1776 dlci = gsm_dlci_alloc(gsm, address);
1780 gsm_response(gsm, address, DM);
1782 gsm_response(gsm, address, UA);
1783 gsm_dlci_open(dlci);
1789 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1790 gsm_response(gsm, address, DM);
1793 /* Real close complete */
1794 gsm_response(gsm, address, UA);
1795 gsm_dlci_close(dlci);
1799 if (cr == 0 || dlci == NULL)
1801 switch (dlci->state) {
1803 gsm_dlci_close(dlci);
1806 gsm_dlci_open(dlci);
1810 case DM: /* DM can be valid unsolicited */
1816 gsm_dlci_close(dlci);
1826 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1827 gsm_command(gsm, address, DM|PF);
1830 dlci->data(dlci, gsm->buf, gsm->len);
1843 * gsm0_receive - perform processing for non-transparency
1844 * @gsm: gsm data for this ldisc instance
1847 * Receive bytes in gsm mode 0
1850 static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1854 switch (gsm->state) {
1855 case GSM_SEARCH: /* SOF marker */
1856 if (c == GSM0_SOF) {
1857 gsm->state = GSM_ADDRESS;
1860 gsm->fcs = INIT_FCS;
1863 case GSM_ADDRESS: /* Address EA */
1864 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1865 if (gsm_read_ea(&gsm->address, c))
1866 gsm->state = GSM_CONTROL;
1868 case GSM_CONTROL: /* Control Byte */
1869 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1871 gsm->state = GSM_LEN0;
1873 case GSM_LEN0: /* Length EA */
1874 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1875 if (gsm_read_ea(&gsm->len, c)) {
1876 if (gsm->len > gsm->mru) {
1878 gsm->state = GSM_SEARCH;
1883 gsm->state = GSM_FCS;
1885 gsm->state = GSM_DATA;
1888 gsm->state = GSM_LEN1;
1891 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1893 gsm->len |= len << 7;
1894 if (gsm->len > gsm->mru) {
1896 gsm->state = GSM_SEARCH;
1901 gsm->state = GSM_FCS;
1903 gsm->state = GSM_DATA;
1905 case GSM_DATA: /* Data */
1906 gsm->buf[gsm->count++] = c;
1907 if (gsm->count == gsm->len)
1908 gsm->state = GSM_FCS;
1910 case GSM_FCS: /* FCS follows the packet */
1911 gsm->received_fcs = c;
1913 gsm->state = GSM_SSOF;
1916 if (c == GSM0_SOF) {
1917 gsm->state = GSM_SEARCH;
1925 * gsm1_receive - perform processing for non-transparency
1926 * @gsm: gsm data for this ldisc instance
1929 * Receive bytes in mode 1 (Advanced option)
1932 static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1934 if (c == GSM1_SOF) {
1935 /* EOF is only valid in frame if we have got to the data state
1936 and received at least one byte (the FCS) */
1937 if (gsm->state == GSM_DATA && gsm->count) {
1938 /* Extract the FCS */
1940 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1941 gsm->len = gsm->count;
1943 gsm->state = GSM_START;
1946 /* Any partial frame was a runt so go back to start */
1947 if (gsm->state != GSM_START) {
1949 gsm->state = GSM_START;
1951 /* A SOF in GSM_START means we are still reading idling or
1956 if (c == GSM1_ESCAPE) {
1961 /* Only an unescaped SOF gets us out of GSM search */
1962 if (gsm->state == GSM_SEARCH)
1966 c ^= GSM1_ESCAPE_BITS;
1969 switch (gsm->state) {
1970 case GSM_START: /* First byte after SOF */
1972 gsm->state = GSM_ADDRESS;
1973 gsm->fcs = INIT_FCS;
1975 case GSM_ADDRESS: /* Address continuation */
1976 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1977 if (gsm_read_ea(&gsm->address, c))
1978 gsm->state = GSM_CONTROL;
1980 case GSM_CONTROL: /* Control Byte */
1981 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1984 gsm->state = GSM_DATA;
1986 case GSM_DATA: /* Data */
1987 if (gsm->count > gsm->mru) { /* Allow one for the FCS */
1988 gsm->state = GSM_OVERRUN;
1991 gsm->buf[gsm->count++] = c;
1993 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */
1999 * gsm_error - handle tty error
2001 * @data: byte received (may be invalid)
2002 * @flag: error received
2004 * Handle an error in the receipt of data for a frame. Currently we just
2005 * go back to hunting for a SOF.
2007 * FIXME: better diagnostics ?
2010 static void gsm_error(struct gsm_mux *gsm,
2011 unsigned char data, unsigned char flag)
2013 gsm->state = GSM_SEARCH;
2018 * gsm_cleanup_mux - generic GSM protocol cleanup
2021 * Clean up the bits of the mux which are the same for all framing
2022 * protocols. Remove the mux from the mux table, stop all the timers
2023 * and then shut down each device hanging up the channels as we go.
2026 void gsm_cleanup_mux(struct gsm_mux *gsm)
2029 struct gsm_dlci *dlci = gsm->dlci[0];
2030 struct gsm_msg *txq, *ntxq;
2031 struct gsm_control *gc;
2035 spin_lock(&gsm_mux_lock);
2036 for (i = 0; i < MAX_MUX; i++) {
2037 if (gsm_mux[i] == gsm) {
2042 spin_unlock(&gsm_mux_lock);
2043 WARN_ON(i == MAX_MUX);
2045 /* In theory disconnecting DLCI 0 is sufficient but for some
2046 modems this is apparently not the case. */
2048 gc = gsm_control_send(gsm, CMD_CLD, NULL, 0);
2050 gsm_control_wait(gsm, gc);
2052 del_timer_sync(&gsm->t2_timer);
2053 /* Now we are sure T2 has stopped */
2056 gsm_dlci_begin_close(dlci);
2057 wait_event_interruptible(gsm->event,
2058 dlci->state == DLCI_CLOSED);
2060 /* Free up any link layer users */
2061 for (i = 0; i < NUM_DLCI; i++)
2063 gsm_dlci_release(gsm->dlci[i]);
2064 /* Now wipe the queues */
2065 list_for_each_entry_safe(txq, ntxq, &gsm->tx_list, list)
2067 INIT_LIST_HEAD(&gsm->tx_list);
2069 EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
2072 * gsm_activate_mux - generic GSM setup
2075 * Set up the bits of the mux which are the same for all framing
2076 * protocols. Add the mux to the mux table so it can be opened and
2077 * finally kick off connecting to DLCI 0 on the modem.
2080 int gsm_activate_mux(struct gsm_mux *gsm)
2082 struct gsm_dlci *dlci;
2085 init_timer(&gsm->t2_timer);
2086 gsm->t2_timer.function = gsm_control_retransmit;
2087 gsm->t2_timer.data = (unsigned long)gsm;
2088 init_waitqueue_head(&gsm->event);
2089 spin_lock_init(&gsm->control_lock);
2090 spin_lock_init(&gsm->tx_lock);
2092 if (gsm->encoding == 0)
2093 gsm->receive = gsm0_receive;
2095 gsm->receive = gsm1_receive;
2096 gsm->error = gsm_error;
2098 spin_lock(&gsm_mux_lock);
2099 for (i = 0; i < MAX_MUX; i++) {
2100 if (gsm_mux[i] == NULL) {
2106 spin_unlock(&gsm_mux_lock);
2110 dlci = gsm_dlci_alloc(gsm, 0);
2113 gsm->dead = 0; /* Tty opens are now permissible */
2116 EXPORT_SYMBOL_GPL(gsm_activate_mux);
2119 * gsm_free_mux - free up a mux
2122 * Dispose of allocated resources for a dead mux
2124 void gsm_free_mux(struct gsm_mux *gsm)
2126 kfree(gsm->txframe);
2130 EXPORT_SYMBOL_GPL(gsm_free_mux);
2133 * gsm_free_muxr - free up a mux
2136 * Dispose of allocated resources for a dead mux
2138 static void gsm_free_muxr(struct kref *ref)
2140 struct gsm_mux *gsm = container_of(ref, struct gsm_mux, ref);
2144 static inline void mux_get(struct gsm_mux *gsm)
2146 kref_get(&gsm->ref);
2149 static inline void mux_put(struct gsm_mux *gsm)
2151 kref_put(&gsm->ref, gsm_free_muxr);
2155 * gsm_alloc_mux - allocate a mux
2157 * Creates a new mux ready for activation.
2160 struct gsm_mux *gsm_alloc_mux(void)
2162 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2165 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2166 if (gsm->buf == NULL) {
2170 gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2171 if (gsm->txframe == NULL) {
2176 spin_lock_init(&gsm->lock);
2177 kref_init(&gsm->ref);
2178 INIT_LIST_HEAD(&gsm->tx_list);
2186 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
2188 gsm->dead = 1; /* Avoid early tty opens */
2192 EXPORT_SYMBOL_GPL(gsm_alloc_mux);
2195 * gsmld_output - write to link
2197 * @data: bytes to output
2200 * Write a block of data from the GSM mux to the data channel. This
2201 * will eventually be serialized from above but at the moment isn't.
2204 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2206 if (tty_write_room(gsm->tty) < len) {
2207 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2211 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET,
2213 gsm->tty->ops->write(gsm->tty, data, len);
2218 * gsmld_attach_gsm - mode set up
2219 * @tty: our tty structure
2222 * Set up the MUX for basic mode and commence connecting to the
2223 * modem. Currently called from the line discipline set up but
2224 * will need moving to an ioctl path.
2227 static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2230 int base = gsm->num << 6; /* Base for this MUX */
2232 gsm->tty = tty_kref_get(tty);
2233 gsm->output = gsmld_output;
2234 ret = gsm_activate_mux(gsm);
2236 tty_kref_put(gsm->tty);
2238 /* Don't register device 0 - this is the control channel and not
2239 a usable tty interface */
2240 for (i = 1; i < NUM_DLCI; i++)
2241 tty_register_device(gsm_tty_driver, base + i, NULL);
2248 * gsmld_detach_gsm - stop doing 0710 mux
2249 * @tty: tty attached to the mux
2252 * Shutdown and then clean up the resources used by the line discipline
2255 static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2258 int base = gsm->num << 6; /* Base for this MUX */
2260 WARN_ON(tty != gsm->tty);
2261 for (i = 1; i < NUM_DLCI; i++)
2262 tty_unregister_device(gsm_tty_driver, base + i);
2263 gsm_cleanup_mux(gsm);
2264 tty_kref_put(gsm->tty);
2268 static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2269 char *fp, int count)
2271 struct gsm_mux *gsm = tty->disc_data;
2272 const unsigned char *dp;
2279 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET,
2282 for (i = count, dp = cp, f = fp; i; i--, dp++) {
2286 gsm->receive(gsm, *dp);
2292 gsm->error(gsm, *dp, flags);
2295 WARN_ONCE(1, "%s: unknown flag %d\n",
2296 tty_name(tty, buf), flags);
2300 /* FASYNC if needed ? */
2301 /* If clogged call tty_throttle(tty); */
2305 * gsmld_chars_in_buffer - report available bytes
2308 * Report the number of characters buffered to be delivered to user
2309 * at this instant in time.
2314 static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
2320 * gsmld_flush_buffer - clean input queue
2321 * @tty: terminal device
2323 * Flush the input buffer. Called when the line discipline is
2324 * being closed, when the tty layer wants the buffer flushed (eg
2328 static void gsmld_flush_buffer(struct tty_struct *tty)
2333 * gsmld_close - close the ldisc for this tty
2336 * Called from the terminal layer when this line discipline is
2337 * being shut down, either because of a close or becsuse of a
2338 * discipline change. The function will not be called while other
2339 * ldisc methods are in progress.
2342 static void gsmld_close(struct tty_struct *tty)
2344 struct gsm_mux *gsm = tty->disc_data;
2346 gsmld_detach_gsm(tty, gsm);
2348 gsmld_flush_buffer(tty);
2349 /* Do other clean up here */
2354 * gsmld_open - open an ldisc
2355 * @tty: terminal to open
2357 * Called when this line discipline is being attached to the
2358 * terminal device. Can sleep. Called serialized so that no
2359 * other events will occur in parallel. No further open will occur
2363 static int gsmld_open(struct tty_struct *tty)
2365 struct gsm_mux *gsm;
2367 if (tty->ops->write == NULL)
2370 /* Attach our ldisc data */
2371 gsm = gsm_alloc_mux();
2375 tty->disc_data = gsm;
2376 tty->receive_room = 65536;
2378 /* Attach the initial passive connection */
2380 return gsmld_attach_gsm(tty, gsm);
2384 * gsmld_write_wakeup - asynchronous I/O notifier
2387 * Required for the ptys, serial driver etc. since processes
2388 * that attach themselves to the master and rely on ASYNC
2389 * IO must be woken up
2392 static void gsmld_write_wakeup(struct tty_struct *tty)
2394 struct gsm_mux *gsm = tty->disc_data;
2395 unsigned long flags;
2398 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2399 spin_lock_irqsave(&gsm->tx_lock, flags);
2401 if (gsm->tx_bytes < TX_THRESH_LO) {
2402 gsm_dlci_data_sweep(gsm);
2404 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2408 * gsmld_read - read function for tty
2410 * @file: file object
2411 * @buf: userspace buffer pointer
2414 * Perform reads for the line discipline. We are guaranteed that the
2415 * line discipline will not be closed under us but we may get multiple
2416 * parallel readers and must handle this ourselves. We may also get
2417 * a hangup. Always called in user context, may sleep.
2419 * This code must be sure never to sleep through a hangup.
2422 static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2423 unsigned char __user *buf, size_t nr)
2429 * gsmld_write - write function for tty
2431 * @file: file object
2432 * @buf: userspace buffer pointer
2435 * Called when the owner of the device wants to send a frame
2436 * itself (or some other control data). The data is transferred
2437 * as-is and must be properly framed and checksummed as appropriate
2438 * by userspace. Frames are either sent whole or not at all as this
2439 * avoids pain user side.
2442 static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2443 const unsigned char *buf, size_t nr)
2445 int space = tty_write_room(tty);
2447 return tty->ops->write(tty, buf, nr);
2448 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2453 * gsmld_poll - poll method for N_GSM0710
2454 * @tty: terminal device
2455 * @file: file accessing it
2458 * Called when the line discipline is asked to poll() for data or
2459 * for special events. This code is not serialized with respect to
2460 * other events save open/close.
2462 * This code must be sure never to sleep through a hangup.
2463 * Called without the kernel lock held - fine
2466 static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2469 unsigned int mask = 0;
2470 struct gsm_mux *gsm = tty->disc_data;
2472 poll_wait(file, &tty->read_wait, wait);
2473 poll_wait(file, &tty->write_wait, wait);
2474 if (tty_hung_up_p(file))
2476 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2477 mask |= POLLOUT | POLLWRNORM;
2483 static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2484 struct gsm_config *c)
2487 int need_restart = 0;
2489 /* Stuff we don't support yet - UI or I frame transport, windowing */
2490 if ((c->adaption != 1 && c->adaption != 2) || c->k)
2492 /* Check the MRU/MTU range looks sane */
2493 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2497 if (c->encapsulation > 1) /* Basic, advanced, no I */
2499 if (c->initiator > 1)
2501 if (c->i == 0 || c->i > 2) /* UIH and UI only */
2504 * See what is needed for reconfiguration
2508 if (c->t1 != 0 && c->t1 != gsm->t1)
2510 if (c->t2 != 0 && c->t2 != gsm->t2)
2512 if (c->encapsulation != gsm->encoding)
2514 if (c->adaption != gsm->adaption)
2517 if (c->initiator != gsm->initiator)
2519 if (c->mru != gsm->mru)
2521 if (c->mtu != gsm->mtu)
2525 * Close down what is needed, restart and initiate the new
2529 if (need_close || need_restart) {
2530 gsm_dlci_begin_close(gsm->dlci[0]);
2531 /* This will timeout if the link is down due to N2 expiring */
2532 wait_event_interruptible(gsm->event,
2533 gsm->dlci[0]->state == DLCI_CLOSED);
2534 if (signal_pending(current))
2538 gsm_cleanup_mux(gsm);
2540 gsm->initiator = c->initiator;
2543 gsm->encoding = c->encapsulation;
2544 gsm->adaption = c->adaption;
2557 /* FIXME: We need to separate activation/deactivation from adding
2558 and removing from the mux array */
2560 gsm_activate_mux(gsm);
2561 if (gsm->initiator && need_close)
2562 gsm_dlci_begin_open(gsm->dlci[0]);
2566 static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2567 unsigned int cmd, unsigned long arg)
2569 struct gsm_config c;
2570 struct gsm_mux *gsm = tty->disc_data;
2573 case GSMIOC_GETCONF:
2574 memset(&c, 0, sizeof(c));
2575 c.adaption = gsm->adaption;
2576 c.encapsulation = gsm->encoding;
2577 c.initiator = gsm->initiator;
2580 c.t3 = 0; /* Not supported */
2582 if (gsm->ftype == UIH)
2586 pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
2590 if (copy_to_user((void *)arg, &c, sizeof(c)))
2593 case GSMIOC_SETCONF:
2594 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2596 return gsmld_config(tty, gsm, &c);
2598 return n_tty_ioctl_helper(tty, file, cmd, arg);
2607 static int gsm_mux_net_open(struct net_device *net)
2609 pr_debug("%s called\n", __func__);
2610 netif_start_queue(net);
2614 static int gsm_mux_net_close(struct net_device *net)
2616 netif_stop_queue(net);
2620 static struct net_device_stats *gsm_mux_net_get_stats(struct net_device *net)
2622 return &((struct gsm_mux_net *)netdev_priv(net))->stats;
2624 static void dlci_net_free(struct gsm_dlci *dlci)
2630 dlci->adaption = dlci->prev_adaption;
2631 dlci->data = dlci->prev_data;
2632 free_netdev(dlci->net);
2635 static void net_free(struct kref *ref)
2637 struct gsm_mux_net *mux_net;
2638 struct gsm_dlci *dlci;
2640 mux_net = container_of(ref, struct gsm_mux_net, ref);
2641 dlci = mux_net->dlci;
2644 unregister_netdev(dlci->net);
2645 dlci_net_free(dlci);
2649 static inline void muxnet_get(struct gsm_mux_net *mux_net)
2651 kref_get(&mux_net->ref);
2654 static inline void muxnet_put(struct gsm_mux_net *mux_net)
2656 kref_put(&mux_net->ref, net_free);
2659 static int gsm_mux_net_start_xmit(struct sk_buff *skb,
2660 struct net_device *net)
2662 struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
2663 struct gsm_dlci *dlci = mux_net->dlci;
2664 muxnet_get(mux_net);
2666 skb_queue_head(&dlci->skb_list, skb);
2667 STATS(net).tx_packets++;
2668 STATS(net).tx_bytes += skb->len;
2669 gsm_dlci_data_kick(dlci);
2670 /* And tell the kernel when the last transmit started. */
2671 net->trans_start = jiffies;
2672 muxnet_put(mux_net);
2673 return NETDEV_TX_OK;
2676 /* called when a packet did not ack after watchdogtimeout */
2677 static void gsm_mux_net_tx_timeout(struct net_device *net)
2679 /* Tell syslog we are hosed. */
2680 dev_dbg(&net->dev, "Tx timed out.\n");
2682 /* Update statistics */
2683 STATS(net).tx_errors++;
2686 static void gsm_mux_rx_netchar(struct gsm_dlci *dlci,
2687 unsigned char *in_buf, int size)
2689 struct net_device *net = dlci->net;
2690 struct sk_buff *skb;
2691 struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
2692 muxnet_get(mux_net);
2694 /* Allocate an sk_buff */
2695 skb = dev_alloc_skb(size + NET_IP_ALIGN);
2697 /* We got no receive buffer. */
2698 STATS(net).rx_dropped++;
2699 muxnet_put(mux_net);
2702 skb_reserve(skb, NET_IP_ALIGN);
2703 memcpy(skb_put(skb, size), in_buf, size);
2706 skb->protocol = __constant_htons(ETH_P_IP);
2708 /* Ship it off to the kernel */
2711 /* update out statistics */
2712 STATS(net).rx_packets++;
2713 STATS(net).rx_bytes += size;
2714 muxnet_put(mux_net);
2718 int gsm_change_mtu(struct net_device *net, int new_mtu)
2720 struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
2721 if ((new_mtu < 8) || (new_mtu > mux_net->dlci->gsm->mtu))
2727 static void gsm_mux_net_init(struct net_device *net)
2729 static const struct net_device_ops gsm_netdev_ops = {
2730 .ndo_open = gsm_mux_net_open,
2731 .ndo_stop = gsm_mux_net_close,
2732 .ndo_start_xmit = gsm_mux_net_start_xmit,
2733 .ndo_tx_timeout = gsm_mux_net_tx_timeout,
2734 .ndo_get_stats = gsm_mux_net_get_stats,
2735 .ndo_change_mtu = gsm_change_mtu,
2738 net->netdev_ops = &gsm_netdev_ops;
2740 /* fill in the other fields */
2741 net->watchdog_timeo = GSM_NET_TX_TIMEOUT;
2742 net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
2743 net->type = ARPHRD_NONE;
2744 net->tx_queue_len = 10;
2748 /* caller holds the dlci mutex */
2749 static void gsm_destroy_network(struct gsm_dlci *dlci)
2751 struct gsm_mux_net *mux_net;
2753 pr_debug("destroy network interface");
2756 mux_net = (struct gsm_mux_net *)netdev_priv(dlci->net);
2757 muxnet_put(mux_net);
2761 /* caller holds the dlci mutex */
2762 static int gsm_create_network(struct gsm_dlci *dlci, struct gsm_netconfig *nc)
2766 struct net_device *net;
2767 struct gsm_mux_net *mux_net;
2769 if (!capable(CAP_NET_ADMIN))
2772 /* Already in a non tty mode */
2773 if (dlci->adaption > 2)
2776 if (nc->protocol != htons(ETH_P_IP))
2777 return -EPROTONOSUPPORT;
2779 if (nc->adaption != 3 && nc->adaption != 4)
2780 return -EPROTONOSUPPORT;
2782 pr_debug("create network interface");
2785 if (nc->if_name[0] != '\0')
2786 netname = nc->if_name;
2787 net = alloc_netdev(sizeof(struct gsm_mux_net),
2791 pr_err("alloc_netdev failed");
2794 net->mtu = dlci->gsm->mtu;
2795 mux_net = (struct gsm_mux_net *)netdev_priv(net);
2796 mux_net->dlci = dlci;
2797 kref_init(&mux_net->ref);
2798 strncpy(nc->if_name, net->name, IFNAMSIZ); /* return net name */
2800 /* reconfigure dlci for network */
2801 dlci->prev_adaption = dlci->adaption;
2802 dlci->prev_data = dlci->data;
2803 dlci->adaption = nc->adaption;
2804 dlci->data = gsm_mux_rx_netchar;
2807 pr_debug("register netdev");
2808 retval = register_netdev(net);
2810 pr_err("network register fail %d\n", retval);
2811 dlci_net_free(dlci);
2814 return net->ifindex; /* return network index */
2817 /* Line discipline for real tty */
2818 struct tty_ldisc_ops tty_ldisc_packet = {
2819 .owner = THIS_MODULE,
2820 .magic = TTY_LDISC_MAGIC,
2823 .close = gsmld_close,
2824 .flush_buffer = gsmld_flush_buffer,
2825 .chars_in_buffer = gsmld_chars_in_buffer,
2827 .write = gsmld_write,
2828 .ioctl = gsmld_ioctl,
2830 .receive_buf = gsmld_receive_buf,
2831 .write_wakeup = gsmld_write_wakeup
2840 static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2843 struct gsm_control *ctrl;
2849 modembits[0] = len << 1 | EA; /* Data bytes */
2850 modembits[1] = dlci->addr << 2 | 3; /* DLCI, EA, 1 */
2851 modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2853 modembits[3] = brk << 4 | 2 | EA; /* Valid, EA */
2854 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2857 return gsm_control_wait(dlci->gsm, ctrl);
2860 static int gsm_carrier_raised(struct tty_port *port)
2862 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2863 /* Not yet open so no carrier info */
2864 if (dlci->state != DLCI_OPEN)
2868 return dlci->modem_rx & TIOCM_CD;
2871 static void gsm_dtr_rts(struct tty_port *port, int onoff)
2873 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2874 unsigned int modem_tx = dlci->modem_tx;
2876 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2878 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2879 if (modem_tx != dlci->modem_tx) {
2880 dlci->modem_tx = modem_tx;
2881 gsmtty_modem_update(dlci, 0);
2885 static const struct tty_port_operations gsm_port_ops = {
2886 .carrier_raised = gsm_carrier_raised,
2887 .dtr_rts = gsm_dtr_rts,
2891 static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2893 struct gsm_mux *gsm;
2894 struct gsm_dlci *dlci;
2895 struct tty_port *port;
2896 unsigned int line = tty->index;
2897 unsigned int mux = line >> 6;
2903 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2904 if (gsm_mux[mux] == NULL)
2906 if (line == 0 || line > 61) /* 62/63 reserved */
2911 /* If DLCI 0 is not yet fully open return an error. This is ok from a locking
2912 perspective as we don't have to worry about this if DLCI0 is lost */
2913 if (gsm->dlci[0] && gsm->dlci[0]->state != DLCI_OPEN)
2915 dlci = gsm->dlci[line];
2917 dlci = gsm_dlci_alloc(gsm, line);
2922 tty->driver_data = dlci;
2924 dlci_get(dlci->gsm->dlci[0]);
2926 tty_port_tty_set(port, tty);
2929 /* We could in theory open and close before we wait - eg if we get
2930 a DM straight back. This is ok as that will have caused a hangup */
2931 set_bit(ASYNCB_INITIALIZED, &port->flags);
2932 /* Start sending off SABM messages */
2933 gsm_dlci_begin_open(dlci);
2934 /* And wait for virtual carrier */
2935 return tty_port_block_til_ready(port, tty, filp);
2938 static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2940 struct gsm_dlci *dlci = tty->driver_data;
2941 struct gsm_mux *gsm;
2945 mutex_lock(&dlci->mutex);
2946 gsm_destroy_network(dlci);
2947 mutex_unlock(&dlci->mutex);
2949 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
2951 gsm_dlci_begin_close(dlci);
2952 tty_port_close_end(&dlci->port, tty);
2953 tty_port_tty_set(&dlci->port, NULL);
2956 dlci_put(gsm->dlci[0]);
2960 static void gsmtty_hangup(struct tty_struct *tty)
2962 struct gsm_dlci *dlci = tty->driver_data;
2963 tty_port_hangup(&dlci->port);
2964 gsm_dlci_begin_close(dlci);
2967 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2970 struct gsm_dlci *dlci = tty->driver_data;
2971 /* Stuff the bytes into the fifo queue */
2972 int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
2973 /* Need to kick the channel */
2974 gsm_dlci_data_kick(dlci);
2978 static int gsmtty_write_room(struct tty_struct *tty)
2980 struct gsm_dlci *dlci = tty->driver_data;
2981 return TX_SIZE - kfifo_len(dlci->fifo);
2984 static int gsmtty_chars_in_buffer(struct tty_struct *tty)
2986 struct gsm_dlci *dlci = tty->driver_data;
2987 return kfifo_len(dlci->fifo);
2990 static void gsmtty_flush_buffer(struct tty_struct *tty)
2992 struct gsm_dlci *dlci = tty->driver_data;
2993 /* Caution needed: If we implement reliable transport classes
2994 then the data being transmitted can't simply be junked once
2995 it has first hit the stack. Until then we can just blow it
2997 kfifo_reset(dlci->fifo);
2998 /* Need to unhook this DLCI from the transmit queue logic */
3001 static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
3003 /* The FIFO handles the queue so the kernel will do the right
3004 thing waiting on chars_in_buffer before calling us. No work
3008 static int gsmtty_tiocmget(struct tty_struct *tty)
3010 struct gsm_dlci *dlci = tty->driver_data;
3011 return dlci->modem_rx;
3014 static int gsmtty_tiocmset(struct tty_struct *tty,
3015 unsigned int set, unsigned int clear)
3017 struct gsm_dlci *dlci = tty->driver_data;
3018 unsigned int modem_tx = dlci->modem_tx;
3023 if (modem_tx != dlci->modem_tx) {
3024 dlci->modem_tx = modem_tx;
3025 return gsmtty_modem_update(dlci, 0);
3031 static int gsmtty_ioctl(struct tty_struct *tty,
3032 unsigned int cmd, unsigned long arg)
3034 struct gsm_dlci *dlci = tty->driver_data;
3035 struct gsm_netconfig nc;
3039 case GSMIOC_ENABLE_NET:
3040 if (copy_from_user(&nc, (void __user *)arg, sizeof(nc)))
3042 nc.if_name[IFNAMSIZ-1] = '\0';
3043 /* return net interface index or error code */
3044 mutex_lock(&dlci->mutex);
3045 index = gsm_create_network(dlci, &nc);
3046 mutex_unlock(&dlci->mutex);
3047 if (copy_to_user((void __user *)arg, &nc, sizeof(nc)))
3050 case GSMIOC_DISABLE_NET:
3051 if (!capable(CAP_NET_ADMIN))
3053 mutex_lock(&dlci->mutex);
3054 gsm_destroy_network(dlci);
3055 mutex_unlock(&dlci->mutex);
3058 return -ENOIOCTLCMD;
3062 static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
3064 /* For the moment its fixed. In actual fact the speed information
3065 for the virtual channel can be propogated in both directions by
3066 the RPN control message. This however rapidly gets nasty as we
3067 then have to remap modem signals each way according to whether
3068 our virtual cable is null modem etc .. */
3069 tty_termios_copy_hw(tty->termios, old);
3072 static void gsmtty_throttle(struct tty_struct *tty)
3074 struct gsm_dlci *dlci = tty->driver_data;
3075 if (tty->termios->c_cflag & CRTSCTS)
3076 dlci->modem_tx &= ~TIOCM_DTR;
3077 dlci->throttled = 1;
3078 /* Send an MSC with DTR cleared */
3079 gsmtty_modem_update(dlci, 0);
3082 static void gsmtty_unthrottle(struct tty_struct *tty)
3084 struct gsm_dlci *dlci = tty->driver_data;
3085 if (tty->termios->c_cflag & CRTSCTS)
3086 dlci->modem_tx |= TIOCM_DTR;
3087 dlci->throttled = 0;
3088 /* Send an MSC with DTR set */
3089 gsmtty_modem_update(dlci, 0);
3092 static int gsmtty_break_ctl(struct tty_struct *tty, int state)
3094 struct gsm_dlci *dlci = tty->driver_data;
3095 int encode = 0; /* Off */
3097 if (state == -1) /* "On indefinitely" - we can't encode this
3100 else if (state > 0) {
3101 encode = state / 200; /* mS to encoding */
3103 encode = 0x0F; /* Best effort */
3105 return gsmtty_modem_update(dlci, encode);
3109 /* Virtual ttys for the demux */
3110 static const struct tty_operations gsmtty_ops = {
3111 .open = gsmtty_open,
3112 .close = gsmtty_close,
3113 .write = gsmtty_write,
3114 .write_room = gsmtty_write_room,
3115 .chars_in_buffer = gsmtty_chars_in_buffer,
3116 .flush_buffer = gsmtty_flush_buffer,
3117 .ioctl = gsmtty_ioctl,
3118 .throttle = gsmtty_throttle,
3119 .unthrottle = gsmtty_unthrottle,
3120 .set_termios = gsmtty_set_termios,
3121 .hangup = gsmtty_hangup,
3122 .wait_until_sent = gsmtty_wait_until_sent,
3123 .tiocmget = gsmtty_tiocmget,
3124 .tiocmset = gsmtty_tiocmset,
3125 .break_ctl = gsmtty_break_ctl,
3130 static int __init gsm_init(void)
3132 /* Fill in our line protocol discipline, and register it */
3133 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
3135 pr_err("n_gsm: can't register line discipline (err = %d)\n",
3140 gsm_tty_driver = alloc_tty_driver(256);
3141 if (!gsm_tty_driver) {
3142 tty_unregister_ldisc(N_GSM0710);
3143 pr_err("gsm_init: tty allocation failed.\n");
3146 gsm_tty_driver->owner = THIS_MODULE;
3147 gsm_tty_driver->driver_name = "gsmtty";
3148 gsm_tty_driver->name = "gsmtty";
3149 gsm_tty_driver->major = 0; /* Dynamic */
3150 gsm_tty_driver->minor_start = 0;
3151 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
3152 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
3153 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
3154 | TTY_DRIVER_HARDWARE_BREAK;
3155 gsm_tty_driver->init_termios = tty_std_termios;
3157 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
3158 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
3160 spin_lock_init(&gsm_mux_lock);
3162 if (tty_register_driver(gsm_tty_driver)) {
3163 put_tty_driver(gsm_tty_driver);
3164 tty_unregister_ldisc(N_GSM0710);
3165 pr_err("gsm_init: tty registration failed.\n");
3168 pr_debug("gsm_init: loaded as %d,%d.\n",
3169 gsm_tty_driver->major, gsm_tty_driver->minor_start);
3173 static void __exit gsm_exit(void)
3175 int status = tty_unregister_ldisc(N_GSM0710);
3177 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
3179 tty_unregister_driver(gsm_tty_driver);
3180 put_tty_driver(gsm_tty_driver);
3183 module_init(gsm_init);
3184 module_exit(gsm_exit);
3187 MODULE_LICENSE("GPL");
3188 MODULE_ALIAS_LDISC(N_GSM0710);