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 */
140 spinlock_t lock; /* Protects the internal state */
141 struct timer_list t1; /* Retransmit timer for SABM and UA */
143 /* Uplink tty if active */
144 struct tty_port port; /* The tty bound to this DLCI if there is one */
145 struct kfifo *fifo; /* Queue fifo for the DLCI */
146 struct kfifo _fifo; /* For new fifo API porting only */
147 int adaption; /* Adaption layer in use */
149 u32 modem_rx; /* Our incoming virtual modem lines */
150 u32 modem_tx; /* Our outgoing modem lines */
151 int dead; /* Refuse re-open */
153 int throttled; /* Private copy of throttle state */
154 int constipated; /* Throttle status for outgoing */
156 struct sk_buff *skb; /* Frame being sent */
157 struct sk_buff_head skb_list; /* Queued frames */
158 /* Data handling callback */
159 void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
160 void (*prev_data)(struct gsm_dlci *dlci, u8 *data, int len);
161 struct net_device *net; /* network interface, if created */
164 /* DLCI 0, 62/63 are special or reseved see gsmtty_open */
169 * DLCI 0 is used to pass control blocks out of band of the data
170 * flow (and with a higher link priority). One command can be outstanding
171 * at a time and we use this structure to manage them. They are created
172 * and destroyed by the user context, and updated by the receive paths
177 u8 cmd; /* Command we are issuing */
178 u8 *data; /* Data for the command in case we retransmit */
179 int len; /* Length of block for retransmission */
180 int done; /* Done flag */
181 int error; /* Error if any */
185 * Each GSM mux we have is represented by this structure. If we are
186 * operating as an ldisc then we use this structure as our ldisc
187 * state. We need to sort out lifetimes and locking with respect
188 * to the gsm mux array. For now we don't free DLCI objects that
189 * have been instantiated until the mux itself is terminated.
191 * To consider further: tty open versus mux shutdown.
195 struct tty_struct *tty; /* The tty our ldisc is bound to */
200 /* Events on the GSM channel */
201 wait_queue_head_t event;
203 /* Bits for GSM mode decoding */
210 #define GSM_ADDRESS 2
211 #define GSM_CONTROL 3
215 #define GSM_OVERRUN 7
220 unsigned int address;
227 u8 *txframe; /* TX framing buffer */
229 /* Methods for the receiver side */
230 void (*receive)(struct gsm_mux *gsm, u8 ch);
231 void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
232 /* And transmit side */
233 int (*output)(struct gsm_mux *mux, u8 *data, int len);
238 int initiator; /* Did we initiate connection */
239 int dead; /* Has the mux been shut down */
240 struct gsm_dlci *dlci[NUM_DLCI];
241 int constipated; /* Asked by remote to shut up */
244 unsigned int tx_bytes; /* TX data outstanding */
245 #define TX_THRESH_HI 8192
246 #define TX_THRESH_LO 2048
247 struct list_head tx_list; /* Pending data packets */
249 /* Control messages */
250 struct timer_list t2_timer; /* Retransmit timer for commands */
251 int cretries; /* Command retry counter */
252 struct gsm_control *pending_cmd;/* Our current pending command */
253 spinlock_t control_lock; /* Protects the pending command */
256 int adaption; /* 1 or 2 supported */
257 u8 ftype; /* UI or UIH */
258 int t1, t2; /* Timers in 1/100th of a sec */
259 int n2; /* Retry count */
261 /* Statistics (not currently exposed) */
262 unsigned long bad_fcs;
263 unsigned long malformed;
264 unsigned long io_error;
265 unsigned long bad_size;
266 unsigned long unsupported;
271 * Mux objects - needed so that we can translate a tty index into the
272 * relevant mux and DLCI.
275 #define MAX_MUX 4 /* 256 minors */
276 static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */
277 static spinlock_t gsm_mux_lock;
279 static struct tty_driver *gsm_tty_driver;
282 * This section of the driver logic implements the GSM encodings
283 * both the basic and the 'advanced'. Reliable transport is not
291 /* I is special: the rest are ..*/
302 /* Channel commands */
304 #define CMD_TEST 0x11
307 #define CMD_FCOFF 0x31
310 #define CMD_FCON 0x51
315 /* Virtual modem bits */
322 #define GSM0_SOF 0xF9
323 #define GSM1_SOF 0x7E
324 #define GSM1_ESCAPE 0x7D
325 #define GSM1_ESCAPE_BITS 0x20
329 static const struct tty_port_operations gsm_port_ops;
332 * CRC table for GSM 0710
335 static const u8 gsm_fcs8[256] = {
336 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
337 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
338 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
339 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
340 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
341 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
342 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
343 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
344 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
345 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
346 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
347 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
348 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
349 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
350 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
351 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
352 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
353 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
354 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
355 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
356 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
357 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
358 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
359 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
360 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
361 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
362 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
363 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
364 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
365 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
366 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
367 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
370 #define INIT_FCS 0xFF
371 #define GOOD_FCS 0xCF
374 * gsm_fcs_add - update FCS
378 * Update the FCS to include c. Uses the algorithm in the specification
382 static inline u8 gsm_fcs_add(u8 fcs, u8 c)
384 return gsm_fcs8[fcs ^ c];
388 * gsm_fcs_add_block - update FCS for a block
391 * @len: length of buffer
393 * Update the FCS to include c. Uses the algorithm in the specification
397 static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
400 fcs = gsm_fcs8[fcs ^ *c++];
405 * gsm_read_ea - read a byte into an EA
406 * @val: variable holding value
407 * c: byte going into the EA
409 * Processes one byte of an EA. Updates the passed variable
410 * and returns 1 if the EA is now completely read
413 static int gsm_read_ea(unsigned int *val, u8 c)
415 /* Add the next 7 bits into the value */
418 /* Was this the last byte of the EA 1 = yes*/
423 * gsm_encode_modem - encode modem data bits
424 * @dlci: DLCI to encode from
426 * Returns the correct GSM encoded modem status bits (6 bit field) for
427 * the current status of the DLCI and attached tty object
430 static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
433 /* FC is true flow control not modem bits */
436 if (dlci->modem_tx & TIOCM_DTR)
437 modembits |= MDM_RTC;
438 if (dlci->modem_tx & TIOCM_RTS)
439 modembits |= MDM_RTR;
440 if (dlci->modem_tx & TIOCM_RI)
442 if (dlci->modem_tx & TIOCM_CD)
448 * gsm_print_packet - display a frame for debug
449 * @hdr: header to print before decode
450 * @addr: address EA from the frame
451 * @cr: C/R bit from the frame
452 * @control: control including PF bit
453 * @data: following data bytes
454 * @dlen: length of data
456 * Displays a packet in human readable format for debugging purposes. The
457 * style is based on amateur radio LAP-B dump display.
460 static void gsm_print_packet(const char *hdr, int addr, int cr,
461 u8 control, const u8 *data, int dlen)
466 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
468 switch (control & ~PF) {
488 if (!(control & 0x01)) {
489 pr_cont("I N(S)%d N(R)%d",
490 (control & 0x0E) >> 1, (control & 0xE0) >> 5);
491 } else switch (control & 0x0F) {
493 pr_cont("RR(%d)", (control & 0xE0) >> 5);
496 pr_cont("RNR(%d)", (control & 0xE0) >> 5);
499 pr_cont("REJ(%d)", (control & 0xE0) >> 5);
502 pr_cont("[%02X]", control);
518 pr_cont("%02X ", *data++);
527 * Link level transmission side
531 * gsm_stuff_packet - bytestuff a packet
534 * @len: length of input
536 * Expand a buffer by bytestuffing it. The worst case size change
537 * is doubling and the caller is responsible for handing out
538 * suitable sized buffers.
541 static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
545 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
546 || *input == XON || *input == XOFF) {
547 *output++ = GSM1_ESCAPE;
548 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
551 *output++ = *input++;
558 * gsm_send - send a control frame
560 * @addr: address for control frame
561 * @cr: command/response bit
562 * @control: control byte including PF bit
564 * Format up and transmit a control frame. These do not go via the
565 * queueing logic as they should be transmitted ahead of data when
568 * FIXME: Lock versus data TX path
571 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 spin_lock_irqsave(&gsm->tx_lock, flags);
607 gsm->output(gsm, cbuf, len);
608 spin_unlock_irqrestore(&gsm->tx_lock, flags);
609 gsm_print_packet("-->", addr, cr, control, NULL, 0);
613 * gsm_response - send a control response
615 * @addr: address for control frame
616 * @control: control byte including PF bit
618 * Format up and transmit a link level response frame.
621 static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
623 gsm_send(gsm, addr, 0, control);
627 * gsm_command - send a control command
629 * @addr: address for control frame
630 * @control: control byte including PF bit
632 * Format up and transmit a link level command frame.
635 static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
637 gsm_send(gsm, addr, 1, control);
640 /* Data transmission */
642 #define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
645 * gsm_data_alloc - allocate data frame
647 * @addr: DLCI address
648 * @len: length excluding header and FCS
649 * @ctrl: control byte
651 * Allocate a new data buffer for sending frames with data. Space is left
652 * at the front for header bytes but that is treated as an implementation
653 * detail and not for the high level code to use
656 static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
659 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
663 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */
667 INIT_LIST_HEAD(&m->list);
672 * gsm_data_kick - poke the queue
675 * The tty device has called us to indicate that room has appeared in
676 * the transmit queue. Ram more data into the pipe if we have any
677 * If we have been flow-stopped by a CMD_FCOFF, then we can only
678 * send messages on DLCI0 until CMD_FCON
680 * FIXME: lock against link layer control transmissions
683 static void gsm_data_kick(struct gsm_mux *gsm)
685 struct gsm_msg *msg, *nmsg;
689 list_for_each_entry_safe(msg, nmsg, &gsm->tx_list, list) {
690 if (gsm->constipated && msg->addr)
692 if (gsm->encoding != 0) {
693 gsm->txframe[0] = GSM1_SOF;
694 len = gsm_stuff_frame(msg->data,
695 gsm->txframe + 1, msg->len);
696 gsm->txframe[len + 1] = GSM1_SOF;
699 gsm->txframe[0] = GSM0_SOF;
700 memcpy(gsm->txframe + 1 , msg->data, msg->len);
701 gsm->txframe[msg->len + 1] = GSM0_SOF;
706 print_hex_dump_bytes("gsm_data_kick: ",
710 if (gsm->output(gsm, gsm->txframe + skip_sof,
713 /* FIXME: Can eliminate one SOF in many more cases */
714 gsm->tx_bytes -= msg->len;
715 /* For a burst of frames skip the extra SOF within the
719 list_del(&msg->list);
725 * __gsm_data_queue - queue a UI or UIH frame
726 * @dlci: DLCI sending the data
727 * @msg: message queued
729 * Add data to the transmit queue and try and get stuff moving
730 * out of the mux tty if not already doing so. The Caller must hold
734 static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
736 struct gsm_mux *gsm = dlci->gsm;
738 u8 *fcs = dp + msg->len;
740 /* Fill in the header */
741 if (gsm->encoding == 0) {
743 *--dp = (msg->len << 1) | EA;
745 *--dp = (msg->len >> 7); /* bits 7 - 15 */
746 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */
752 *--dp = (msg->addr << 2) | 2 | EA;
754 *--dp = (msg->addr << 2) | EA;
755 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
756 /* Ugly protocol layering violation */
757 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
758 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
761 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
762 msg->data, msg->len);
764 /* Move the header back and adjust the length, also allow for the FCS
765 now tacked on the end */
766 msg->len += (msg->data - dp) + 1;
769 /* Add to the actual output queue */
770 list_add_tail(&msg->list, &gsm->tx_list);
771 gsm->tx_bytes += msg->len;
776 * gsm_data_queue - queue a UI or UIH frame
777 * @dlci: DLCI sending the data
778 * @msg: message queued
780 * Add data to the transmit queue and try and get stuff moving
781 * out of the mux tty if not already doing so. Take the
782 * the gsm tx lock and dlci lock.
785 static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
788 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
789 __gsm_data_queue(dlci, msg);
790 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
794 * gsm_dlci_data_output - try and push data out of a DLCI
796 * @dlci: the DLCI to pull data from
798 * Pull data from a DLCI and send it into the transmit queue if there
799 * is data. Keep to the MRU of the mux. This path handles the usual tty
800 * interface which is a byte stream with optional modem data.
802 * Caller must hold the tx_lock of the mux.
805 static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
809 int len, total_size, size;
810 int h = dlci->adaption - 1;
814 len = kfifo_len(dlci->fifo);
818 /* MTU/MRU count only the data bits */
824 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
825 /* FIXME: need a timer or something to kick this so it can't
826 get stuck with no work outstanding and no buffer free */
830 switch (dlci->adaption) {
831 case 1: /* Unstructured */
833 case 2: /* Unstructed with modem bits. Always one byte as we never
834 send inline break data */
835 *dp++ = gsm_encode_modem(dlci);
838 WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
839 __gsm_data_queue(dlci, msg);
842 /* Bytes of data we used up */
847 * gsm_dlci_data_output_framed - try and push data out of a DLCI
849 * @dlci: the DLCI to pull data from
851 * Pull data from a DLCI and send it into the transmit queue if there
852 * is data. Keep to the MRU of the mux. This path handles framed data
853 * queued as skbuffs to the DLCI.
855 * Caller must hold the tx_lock of the mux.
858 static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
859 struct gsm_dlci *dlci)
864 int last = 0, first = 0;
867 /* One byte per frame is used for B/F flags */
868 if (dlci->adaption == 4)
871 /* dlci->skb is locked by tx_lock */
872 if (dlci->skb == NULL) {
873 dlci->skb = skb_dequeue_tail(&dlci->skb_list);
874 if (dlci->skb == NULL)
878 len = dlci->skb->len + overhead;
880 /* MTU/MRU count only the data bits */
881 if (len > gsm->mtu) {
882 if (dlci->adaption == 3) {
883 /* Over long frame, bin it */
884 dev_kfree_skb_any(dlci->skb);
892 size = len + overhead;
893 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
895 /* FIXME: need a timer or something to kick this so it can't
896 get stuck with no work outstanding and no buffer free */
898 skb_queue_tail(&dlci->skb_list, dlci->skb);
904 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
905 /* Flag byte to carry the start/end info */
906 *dp++ = last << 7 | first << 6 | 1; /* EA */
909 memcpy(dp, dlci->skb->data, len);
910 skb_pull(dlci->skb, len);
911 __gsm_data_queue(dlci, msg);
913 dev_kfree_skb_any(dlci->skb);
920 * gsm_dlci_data_sweep - look for data to send
923 * Sweep the GSM mux channels in priority order looking for ones with
924 * data to send. We could do with optimising this scan a bit. We aim
925 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
926 * TX_THRESH_LO we get called again
928 * FIXME: We should round robin between groups and in theory you can
929 * renegotiate DLCI priorities with optional stuff. Needs optimising.
932 static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
935 /* Priority ordering: We should do priority with RR of the groups */
938 while (i < NUM_DLCI) {
939 struct gsm_dlci *dlci;
941 if (gsm->tx_bytes > TX_THRESH_HI)
944 if (dlci == NULL || dlci->constipated) {
948 if (dlci->adaption < 3 && !dlci->net)
949 len = gsm_dlci_data_output(gsm, dlci);
951 len = gsm_dlci_data_output_framed(gsm, dlci);
954 /* DLCI empty - try the next */
961 * gsm_dlci_data_kick - transmit if possible
962 * @dlci: DLCI to kick
964 * Transmit data from this DLCI if the queue is empty. We can't rely on
965 * a tty wakeup except when we filled the pipe so we need to fire off
966 * new data ourselves in other cases.
969 static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
974 if (dlci->constipated)
977 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
978 /* If we have nothing running then we need to fire up */
979 sweep = (dlci->gsm->tx_bytes < TX_THRESH_LO);
980 if (dlci->gsm->tx_bytes == 0) {
982 gsm_dlci_data_output_framed(dlci->gsm, dlci);
984 gsm_dlci_data_output(dlci->gsm, dlci);
987 gsm_dlci_data_sweep(dlci->gsm);
988 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
992 * Control message processing
997 * gsm_control_reply - send a response frame to a control
999 * @cmd: the command to use
1000 * @data: data to follow encoded info
1001 * @dlen: length of data
1003 * Encode up and queue a UI/UIH frame containing our response.
1006 static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
1009 struct gsm_msg *msg;
1010 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
1013 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */
1014 msg->data[1] = (dlen << 1) | EA;
1015 memcpy(msg->data + 2, data, dlen);
1016 gsm_data_queue(gsm->dlci[0], msg);
1020 * gsm_process_modem - process received modem status
1021 * @tty: virtual tty bound to the DLCI
1022 * @dlci: DLCI to affect
1023 * @modem: modem bits (full EA)
1025 * Used when a modem control message or line state inline in adaption
1026 * layer 2 is processed. Sort out the local modem state and throttles
1029 static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
1030 u32 modem, int clen)
1036 /* The modem status command can either contain one octet (v.24 signals)
1037 or two octets (v.24 signals + break signals). The length field will
1038 either be 2 or 3 respectively. This is specified in section
1039 5.4.6.3.7 of the 27.010 mux spec. */
1042 modem = modem & 0x7f;
1045 modem = (modem >> 7) & 0x7f;
1048 /* Flow control/ready to communicate */
1049 fc = (modem & MDM_FC) || !(modem & MDM_RTR);
1050 if (fc && !dlci->constipated) {
1051 /* Need to throttle our output on this device */
1052 dlci->constipated = 1;
1053 } else if (!fc && dlci->constipated) {
1054 dlci->constipated = 0;
1055 gsm_dlci_data_kick(dlci);
1058 /* Map modem bits */
1059 if (modem & MDM_RTC)
1060 mlines |= TIOCM_DSR | TIOCM_DTR;
1061 if (modem & MDM_RTR)
1062 mlines |= TIOCM_RTS | TIOCM_CTS;
1068 /* Carrier drop -> hangup */
1070 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1071 if (!(tty->termios.c_cflag & CLOCAL))
1075 tty_insert_flip_char(&dlci->port, 0, TTY_BREAK);
1076 dlci->modem_rx = mlines;
1080 * gsm_control_modem - modem status received
1082 * @data: data following command
1083 * @clen: command length
1085 * We have received a modem status control message. This is used by
1086 * the GSM mux protocol to pass virtual modem line status and optionally
1087 * to indicate break signals. Unpack it, convert to Linux representation
1088 * and if need be stuff a break message down the tty.
1091 static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1093 unsigned int addr = 0;
1094 unsigned int modem = 0;
1095 struct gsm_dlci *dlci;
1098 struct tty_struct *tty;
1100 while (gsm_read_ea(&addr, *dp++) == 0) {
1105 /* Must be at least one byte following the EA */
1111 /* Closed port, or invalid ? */
1112 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1114 dlci = gsm->dlci[addr];
1116 while (gsm_read_ea(&modem, *dp++) == 0) {
1121 tty = tty_port_tty_get(&dlci->port);
1122 gsm_process_modem(tty, dlci, modem, clen);
1127 gsm_control_reply(gsm, CMD_MSC, data, clen);
1131 * gsm_control_rls - remote line status
1134 * @clen: data length
1136 * The modem sends us a two byte message on the control channel whenever
1137 * it wishes to send us an error state from the virtual link. Stuff
1138 * this into the uplink tty if present
1141 static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1143 struct tty_port *port;
1144 unsigned int addr = 0 ;
1149 while (gsm_read_ea(&addr, *dp++) == 0) {
1154 /* Must be at least one byte following ea */
1159 /* Closed port, or invalid ? */
1160 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1164 if ((bits & 1) == 0)
1167 port = &gsm->dlci[addr]->port;
1170 tty_insert_flip_char(port, 0, TTY_OVERRUN);
1172 tty_insert_flip_char(port, 0, TTY_PARITY);
1174 tty_insert_flip_char(port, 0, TTY_FRAME);
1176 tty_flip_buffer_push(port);
1178 gsm_control_reply(gsm, CMD_RLS, data, clen);
1181 static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1184 * gsm_control_message - DLCI 0 control processing
1186 * @command: the command EA
1187 * @data: data beyond the command/length EAs
1190 * Input processor for control messages from the other end of the link.
1191 * Processes the incoming request and queues a response frame or an
1192 * NSC response if not supported
1195 static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1199 unsigned long flags;
1203 struct gsm_dlci *dlci = gsm->dlci[0];
1204 /* Modem wishes to close down */
1208 gsm_dlci_begin_close(dlci);
1213 /* Modem wishes to test, reply with the data */
1214 gsm_control_reply(gsm, CMD_TEST, data, clen);
1217 /* Modem can accept data again */
1218 gsm->constipated = 0;
1219 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1220 /* Kick the link in case it is idling */
1221 spin_lock_irqsave(&gsm->tx_lock, flags);
1223 spin_unlock_irqrestore(&gsm->tx_lock, flags);
1226 /* Modem wants us to STFU */
1227 gsm->constipated = 1;
1228 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1231 /* Out of band modem line change indicator for a DLCI */
1232 gsm_control_modem(gsm, data, clen);
1235 /* Out of band error reception for a DLCI */
1236 gsm_control_rls(gsm, data, clen);
1239 /* Modem wishes to enter power saving state */
1240 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1242 /* Optional unsupported commands */
1243 case CMD_PN: /* Parameter negotiation */
1244 case CMD_RPN: /* Remote port negotiation */
1245 case CMD_SNC: /* Service negotiation command */
1247 /* Reply to bad commands with an NSC */
1249 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1255 * gsm_control_response - process a response to our control
1257 * @command: the command (response) EA
1258 * @data: data beyond the command/length EA
1261 * Process a response to an outstanding command. We only allow a single
1262 * control message in flight so this is fairly easy. All the clean up
1263 * is done by the caller, we just update the fields, flag it as done
1267 static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1270 struct gsm_control *ctrl;
1271 unsigned long flags;
1273 spin_lock_irqsave(&gsm->control_lock, flags);
1275 ctrl = gsm->pending_cmd;
1276 /* Does the reply match our command */
1278 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1279 /* Our command was replied to, kill the retry timer */
1280 del_timer(&gsm->t2_timer);
1281 gsm->pending_cmd = NULL;
1282 /* Rejected by the other end */
1283 if (command == CMD_NSC)
1284 ctrl->error = -EOPNOTSUPP;
1286 wake_up(&gsm->event);
1288 spin_unlock_irqrestore(&gsm->control_lock, flags);
1292 * gsm_control_transmit - send control packet
1294 * @ctrl: frame to send
1296 * Send out a pending control command (called under control lock)
1299 static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1301 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype);
1304 msg->data[0] = (ctrl->cmd << 1) | 2 | EA; /* command */
1305 memcpy(msg->data + 1, ctrl->data, ctrl->len);
1306 gsm_data_queue(gsm->dlci[0], msg);
1310 * gsm_control_retransmit - retransmit a control frame
1311 * @data: pointer to our gsm object
1313 * Called off the T2 timer expiry in order to retransmit control frames
1314 * that have been lost in the system somewhere. The control_lock protects
1315 * us from colliding with another sender or a receive completion event.
1316 * In that situation the timer may still occur in a small window but
1317 * gsm->pending_cmd will be NULL and we just let the timer expire.
1320 static void gsm_control_retransmit(unsigned long data)
1322 struct gsm_mux *gsm = (struct gsm_mux *)data;
1323 struct gsm_control *ctrl;
1324 unsigned long flags;
1325 spin_lock_irqsave(&gsm->control_lock, flags);
1326 ctrl = gsm->pending_cmd;
1329 if (gsm->cretries == 0) {
1330 gsm->pending_cmd = NULL;
1331 ctrl->error = -ETIMEDOUT;
1333 spin_unlock_irqrestore(&gsm->control_lock, flags);
1334 wake_up(&gsm->event);
1337 gsm_control_transmit(gsm, ctrl);
1338 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1340 spin_unlock_irqrestore(&gsm->control_lock, flags);
1344 * gsm_control_send - send a control frame on DLCI 0
1345 * @gsm: the GSM channel
1346 * @command: command to send including CR bit
1347 * @data: bytes of data (must be kmalloced)
1348 * @len: length of the block to send
1350 * Queue and dispatch a control command. Only one command can be
1351 * active at a time. In theory more can be outstanding but the matching
1352 * gets really complicated so for now stick to one outstanding.
1355 static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1356 unsigned int command, u8 *data, int clen)
1358 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1360 unsigned long flags;
1364 wait_event(gsm->event, gsm->pending_cmd == NULL);
1365 spin_lock_irqsave(&gsm->control_lock, flags);
1366 if (gsm->pending_cmd != NULL) {
1367 spin_unlock_irqrestore(&gsm->control_lock, flags);
1370 ctrl->cmd = command;
1373 gsm->pending_cmd = ctrl;
1374 gsm->cretries = gsm->n2;
1375 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1376 gsm_control_transmit(gsm, ctrl);
1377 spin_unlock_irqrestore(&gsm->control_lock, flags);
1382 * gsm_control_wait - wait for a control to finish
1384 * @control: control we are waiting on
1386 * Waits for the control to complete or time out. Frees any used
1387 * resources and returns 0 for success, or an error if the remote
1388 * rejected or ignored the request.
1391 static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1394 wait_event(gsm->event, control->done == 1);
1395 err = control->error;
1402 * DLCI level handling: Needs krefs
1406 * State transitions and timers
1410 * gsm_dlci_close - a DLCI has closed
1411 * @dlci: DLCI that closed
1413 * Perform processing when moving a DLCI into closed state. If there
1414 * is an attached tty this is hung up
1417 static void gsm_dlci_close(struct gsm_dlci *dlci)
1419 del_timer(&dlci->t1);
1421 pr_debug("DLCI %d goes closed.\n", dlci->addr);
1422 dlci->state = DLCI_CLOSED;
1423 if (dlci->addr != 0) {
1424 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1429 kfifo_reset(dlci->fifo);
1431 dlci->gsm->dead = 1;
1432 wake_up(&dlci->gsm->event);
1433 /* A DLCI 0 close is a MUX termination so we need to kick that
1434 back to userspace somehow */
1438 * gsm_dlci_open - a DLCI has opened
1439 * @dlci: DLCI that opened
1441 * Perform processing when moving a DLCI into open state.
1444 static void gsm_dlci_open(struct gsm_dlci *dlci)
1446 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1448 del_timer(&dlci->t1);
1449 /* This will let a tty open continue */
1450 dlci->state = DLCI_OPEN;
1452 pr_debug("DLCI %d goes open.\n", dlci->addr);
1453 wake_up(&dlci->gsm->event);
1457 * gsm_dlci_t1 - T1 timer expiry
1458 * @dlci: DLCI that opened
1460 * The T1 timer handles retransmits of control frames (essentially of
1461 * SABM and DISC). We resend the command until the retry count runs out
1462 * in which case an opening port goes back to closed and a closing port
1463 * is simply put into closed state (any further frames from the other
1464 * end will get a DM response)
1467 static void gsm_dlci_t1(unsigned long data)
1469 struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1470 struct gsm_mux *gsm = dlci->gsm;
1472 switch (dlci->state) {
1475 if (dlci->retries) {
1476 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1477 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1479 gsm_dlci_close(dlci);
1483 if (dlci->retries) {
1484 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1485 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1487 gsm_dlci_close(dlci);
1493 * gsm_dlci_begin_open - start channel open procedure
1494 * @dlci: DLCI to open
1496 * Commence opening a DLCI from the Linux side. We issue SABM messages
1497 * to the modem which should then reply with a UA, at which point we
1498 * will move into open state. Opening is done asynchronously with retry
1499 * running off timers and the responses.
1502 static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1504 struct gsm_mux *gsm = dlci->gsm;
1505 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1507 dlci->retries = gsm->n2;
1508 dlci->state = DLCI_OPENING;
1509 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1510 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1514 * gsm_dlci_begin_close - start channel open procedure
1515 * @dlci: DLCI to open
1517 * Commence closing a DLCI from the Linux side. We issue DISC messages
1518 * to the modem which should then reply with a UA, at which point we
1519 * will move into closed state. Closing is done asynchronously with retry
1520 * off timers. We may also receive a DM reply from the other end which
1521 * indicates the channel was already closed.
1524 static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1526 struct gsm_mux *gsm = dlci->gsm;
1527 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1529 dlci->retries = gsm->n2;
1530 dlci->state = DLCI_CLOSING;
1531 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1532 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1536 * gsm_dlci_data - data arrived
1538 * @data: block of bytes received
1539 * @len: length of received block
1541 * A UI or UIH frame has arrived which contains data for a channel
1542 * other than the control channel. If the relevant virtual tty is
1543 * open we shovel the bits down it, if not we drop them.
1546 static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int clen)
1549 struct tty_port *port = &dlci->port;
1550 struct tty_struct *tty;
1551 unsigned int modem = 0;
1555 pr_debug("%d bytes for tty\n", len);
1556 switch (dlci->adaption) {
1557 /* Unsupported types */
1558 /* Packetised interruptible data */
1561 /* Packetised uininterruptible voice/data */
1564 /* Asynchronous serial with line state in each frame */
1566 while (gsm_read_ea(&modem, *data++) == 0) {
1571 tty = tty_port_tty_get(port);
1573 gsm_process_modem(tty, dlci, modem, clen);
1576 /* Line state will go via DLCI 0 controls only */
1579 tty_insert_flip_string(port, data, len);
1580 tty_flip_buffer_push(port);
1585 * gsm_dlci_control - data arrived on control channel
1587 * @data: block of bytes received
1588 * @len: length of received block
1590 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1591 * control channel. This should contain a command EA followed by
1592 * control data bytes. The command EA contains a command/response bit
1593 * and we divide up the work accordingly.
1596 static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1598 /* See what command is involved */
1599 unsigned int command = 0;
1601 if (gsm_read_ea(&command, *data++) == 1) {
1604 /* FIXME: this is properly an EA */
1606 /* Malformed command ? */
1610 gsm_control_message(dlci->gsm, command,
1613 gsm_control_response(dlci->gsm, command,
1621 * Allocate/Free DLCI channels
1625 * gsm_dlci_alloc - allocate a DLCI
1627 * @addr: address of the DLCI
1629 * Allocate and install a new DLCI object into the GSM mux.
1631 * FIXME: review locking races
1634 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1636 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1639 spin_lock_init(&dlci->lock);
1640 mutex_init(&dlci->mutex);
1641 dlci->fifo = &dlci->_fifo;
1642 if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1647 skb_queue_head_init(&dlci->skb_list);
1648 init_timer(&dlci->t1);
1649 dlci->t1.function = gsm_dlci_t1;
1650 dlci->t1.data = (unsigned long)dlci;
1651 tty_port_init(&dlci->port);
1652 dlci->port.ops = &gsm_port_ops;
1655 dlci->adaption = gsm->adaption;
1656 dlci->state = DLCI_CLOSED;
1658 dlci->data = gsm_dlci_data;
1660 dlci->data = gsm_dlci_command;
1661 gsm->dlci[addr] = dlci;
1666 * gsm_dlci_free - free DLCI
1667 * @dlci: DLCI to free
1673 static void gsm_dlci_free(struct tty_port *port)
1675 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
1677 del_timer_sync(&dlci->t1);
1678 dlci->gsm->dlci[dlci->addr] = NULL;
1679 kfifo_free(dlci->fifo);
1680 while ((dlci->skb = skb_dequeue(&dlci->skb_list)))
1681 dev_kfree_skb(dlci->skb);
1685 static inline void dlci_get(struct gsm_dlci *dlci)
1687 tty_port_get(&dlci->port);
1690 static inline void dlci_put(struct gsm_dlci *dlci)
1692 tty_port_put(&dlci->port);
1696 * gsm_dlci_release - release DLCI
1697 * @dlci: DLCI to destroy
1699 * Release a DLCI. Actual free is deferred until either
1700 * mux is closed or tty is closed - whichever is last.
1704 static void gsm_dlci_release(struct gsm_dlci *dlci)
1706 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1715 * LAPBish link layer logic
1719 * gsm_queue - a GSM frame is ready to process
1720 * @gsm: pointer to our gsm mux
1722 * At this point in time a frame has arrived and been demangled from
1723 * the line encoding. All the differences between the encodings have
1724 * been handled below us and the frame is unpacked into the structures.
1725 * The fcs holds the header FCS but any data FCS must be added here.
1728 static void gsm_queue(struct gsm_mux *gsm)
1730 struct gsm_dlci *dlci;
1733 /* We have to sneak a look at the packet body to do the FCS.
1734 A somewhat layering violation in the spec */
1736 if ((gsm->control & ~PF) == UI)
1737 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1738 if (gsm->encoding == 0){
1739 /* WARNING: gsm->received_fcs is used for gsm->encoding = 0 only.
1740 In this case it contain the last piece of data
1741 required to generate final CRC */
1742 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1744 if (gsm->fcs != GOOD_FCS) {
1747 pr_debug("BAD FCS %02x\n", gsm->fcs);
1750 address = gsm->address >> 1;
1751 if (address >= NUM_DLCI)
1754 cr = gsm->address & 1; /* C/R bit */
1756 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1758 cr ^= 1 - gsm->initiator; /* Flip so 1 always means command */
1759 dlci = gsm->dlci[address];
1761 switch (gsm->control) {
1766 dlci = gsm_dlci_alloc(gsm, address);
1770 gsm_response(gsm, address, DM);
1772 gsm_response(gsm, address, UA);
1773 gsm_dlci_open(dlci);
1779 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1780 gsm_response(gsm, address, DM);
1783 /* Real close complete */
1784 gsm_response(gsm, address, UA);
1785 gsm_dlci_close(dlci);
1789 if (cr == 0 || dlci == NULL)
1791 switch (dlci->state) {
1793 gsm_dlci_close(dlci);
1796 gsm_dlci_open(dlci);
1800 case DM: /* DM can be valid unsolicited */
1806 gsm_dlci_close(dlci);
1816 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1817 gsm_command(gsm, address, DM|PF);
1820 dlci->data(dlci, gsm->buf, gsm->len);
1833 * gsm0_receive - perform processing for non-transparency
1834 * @gsm: gsm data for this ldisc instance
1837 * Receive bytes in gsm mode 0
1840 static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1844 switch (gsm->state) {
1845 case GSM_SEARCH: /* SOF marker */
1846 if (c == GSM0_SOF) {
1847 gsm->state = GSM_ADDRESS;
1850 gsm->fcs = INIT_FCS;
1853 case GSM_ADDRESS: /* Address EA */
1854 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1855 if (gsm_read_ea(&gsm->address, c))
1856 gsm->state = GSM_CONTROL;
1858 case GSM_CONTROL: /* Control Byte */
1859 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1861 gsm->state = GSM_LEN0;
1863 case GSM_LEN0: /* Length EA */
1864 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1865 if (gsm_read_ea(&gsm->len, c)) {
1866 if (gsm->len > gsm->mru) {
1868 gsm->state = GSM_SEARCH;
1873 gsm->state = GSM_FCS;
1875 gsm->state = GSM_DATA;
1878 gsm->state = GSM_LEN1;
1881 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1883 gsm->len |= len << 7;
1884 if (gsm->len > gsm->mru) {
1886 gsm->state = GSM_SEARCH;
1891 gsm->state = GSM_FCS;
1893 gsm->state = GSM_DATA;
1895 case GSM_DATA: /* Data */
1896 gsm->buf[gsm->count++] = c;
1897 if (gsm->count == gsm->len)
1898 gsm->state = GSM_FCS;
1900 case GSM_FCS: /* FCS follows the packet */
1901 gsm->received_fcs = c;
1903 gsm->state = GSM_SSOF;
1906 if (c == GSM0_SOF) {
1907 gsm->state = GSM_SEARCH;
1915 * gsm1_receive - perform processing for non-transparency
1916 * @gsm: gsm data for this ldisc instance
1919 * Receive bytes in mode 1 (Advanced option)
1922 static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1924 if (c == GSM1_SOF) {
1925 /* EOF is only valid in frame if we have got to the data state
1926 and received at least one byte (the FCS) */
1927 if (gsm->state == GSM_DATA && gsm->count) {
1928 /* Extract the FCS */
1930 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1931 gsm->len = gsm->count;
1933 gsm->state = GSM_START;
1936 /* Any partial frame was a runt so go back to start */
1937 if (gsm->state != GSM_START) {
1939 gsm->state = GSM_START;
1941 /* A SOF in GSM_START means we are still reading idling or
1946 if (c == GSM1_ESCAPE) {
1951 /* Only an unescaped SOF gets us out of GSM search */
1952 if (gsm->state == GSM_SEARCH)
1956 c ^= GSM1_ESCAPE_BITS;
1959 switch (gsm->state) {
1960 case GSM_START: /* First byte after SOF */
1962 gsm->state = GSM_ADDRESS;
1963 gsm->fcs = INIT_FCS;
1965 case GSM_ADDRESS: /* Address continuation */
1966 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1967 if (gsm_read_ea(&gsm->address, c))
1968 gsm->state = GSM_CONTROL;
1970 case GSM_CONTROL: /* Control Byte */
1971 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1974 gsm->state = GSM_DATA;
1976 case GSM_DATA: /* Data */
1977 if (gsm->count > gsm->mru) { /* Allow one for the FCS */
1978 gsm->state = GSM_OVERRUN;
1981 gsm->buf[gsm->count++] = c;
1983 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */
1989 * gsm_error - handle tty error
1991 * @data: byte received (may be invalid)
1992 * @flag: error received
1994 * Handle an error in the receipt of data for a frame. Currently we just
1995 * go back to hunting for a SOF.
1997 * FIXME: better diagnostics ?
2000 static void gsm_error(struct gsm_mux *gsm,
2001 unsigned char data, unsigned char flag)
2003 gsm->state = GSM_SEARCH;
2008 * gsm_cleanup_mux - generic GSM protocol cleanup
2011 * Clean up the bits of the mux which are the same for all framing
2012 * protocols. Remove the mux from the mux table, stop all the timers
2013 * and then shut down each device hanging up the channels as we go.
2016 void gsm_cleanup_mux(struct gsm_mux *gsm)
2019 struct gsm_dlci *dlci = gsm->dlci[0];
2020 struct gsm_msg *txq, *ntxq;
2021 struct gsm_control *gc;
2025 spin_lock(&gsm_mux_lock);
2026 for (i = 0; i < MAX_MUX; i++) {
2027 if (gsm_mux[i] == gsm) {
2032 spin_unlock(&gsm_mux_lock);
2033 WARN_ON(i == MAX_MUX);
2035 /* In theory disconnecting DLCI 0 is sufficient but for some
2036 modems this is apparently not the case. */
2038 gc = gsm_control_send(gsm, CMD_CLD, NULL, 0);
2040 gsm_control_wait(gsm, gc);
2042 del_timer_sync(&gsm->t2_timer);
2043 /* Now we are sure T2 has stopped */
2046 gsm_dlci_begin_close(dlci);
2047 wait_event_interruptible(gsm->event,
2048 dlci->state == DLCI_CLOSED);
2050 /* Free up any link layer users */
2051 for (i = 0; i < NUM_DLCI; i++)
2053 gsm_dlci_release(gsm->dlci[i]);
2054 /* Now wipe the queues */
2055 list_for_each_entry_safe(txq, ntxq, &gsm->tx_list, list)
2057 INIT_LIST_HEAD(&gsm->tx_list);
2059 EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
2062 * gsm_activate_mux - generic GSM setup
2065 * Set up the bits of the mux which are the same for all framing
2066 * protocols. Add the mux to the mux table so it can be opened and
2067 * finally kick off connecting to DLCI 0 on the modem.
2070 int gsm_activate_mux(struct gsm_mux *gsm)
2072 struct gsm_dlci *dlci;
2075 init_timer(&gsm->t2_timer);
2076 gsm->t2_timer.function = gsm_control_retransmit;
2077 gsm->t2_timer.data = (unsigned long)gsm;
2078 init_waitqueue_head(&gsm->event);
2079 spin_lock_init(&gsm->control_lock);
2080 spin_lock_init(&gsm->tx_lock);
2082 if (gsm->encoding == 0)
2083 gsm->receive = gsm0_receive;
2085 gsm->receive = gsm1_receive;
2086 gsm->error = gsm_error;
2088 spin_lock(&gsm_mux_lock);
2089 for (i = 0; i < MAX_MUX; i++) {
2090 if (gsm_mux[i] == NULL) {
2096 spin_unlock(&gsm_mux_lock);
2100 dlci = gsm_dlci_alloc(gsm, 0);
2103 gsm->dead = 0; /* Tty opens are now permissible */
2106 EXPORT_SYMBOL_GPL(gsm_activate_mux);
2109 * gsm_free_mux - free up a mux
2112 * Dispose of allocated resources for a dead mux
2114 void gsm_free_mux(struct gsm_mux *gsm)
2116 kfree(gsm->txframe);
2120 EXPORT_SYMBOL_GPL(gsm_free_mux);
2123 * gsm_free_muxr - free up a mux
2126 * Dispose of allocated resources for a dead mux
2128 static void gsm_free_muxr(struct kref *ref)
2130 struct gsm_mux *gsm = container_of(ref, struct gsm_mux, ref);
2134 static inline void mux_get(struct gsm_mux *gsm)
2136 kref_get(&gsm->ref);
2139 static inline void mux_put(struct gsm_mux *gsm)
2141 kref_put(&gsm->ref, gsm_free_muxr);
2145 * gsm_alloc_mux - allocate a mux
2147 * Creates a new mux ready for activation.
2150 struct gsm_mux *gsm_alloc_mux(void)
2152 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2155 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2156 if (gsm->buf == NULL) {
2160 gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2161 if (gsm->txframe == NULL) {
2166 spin_lock_init(&gsm->lock);
2167 kref_init(&gsm->ref);
2168 INIT_LIST_HEAD(&gsm->tx_list);
2176 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
2178 gsm->dead = 1; /* Avoid early tty opens */
2182 EXPORT_SYMBOL_GPL(gsm_alloc_mux);
2185 * gsmld_output - write to link
2187 * @data: bytes to output
2190 * Write a block of data from the GSM mux to the data channel. This
2191 * will eventually be serialized from above but at the moment isn't.
2194 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2196 if (tty_write_room(gsm->tty) < len) {
2197 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2201 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET,
2203 gsm->tty->ops->write(gsm->tty, data, len);
2208 * gsmld_attach_gsm - mode set up
2209 * @tty: our tty structure
2212 * Set up the MUX for basic mode and commence connecting to the
2213 * modem. Currently called from the line discipline set up but
2214 * will need moving to an ioctl path.
2217 static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2220 int base = gsm->num << 6; /* Base for this MUX */
2222 gsm->tty = tty_kref_get(tty);
2223 gsm->output = gsmld_output;
2224 ret = gsm_activate_mux(gsm);
2226 tty_kref_put(gsm->tty);
2228 /* Don't register device 0 - this is the control channel and not
2229 a usable tty interface */
2230 for (i = 1; i < NUM_DLCI; i++)
2231 tty_register_device(gsm_tty_driver, base + i, NULL);
2238 * gsmld_detach_gsm - stop doing 0710 mux
2239 * @tty: tty attached to the mux
2242 * Shutdown and then clean up the resources used by the line discipline
2245 static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2248 int base = gsm->num << 6; /* Base for this MUX */
2250 WARN_ON(tty != gsm->tty);
2251 for (i = 1; i < NUM_DLCI; i++)
2252 tty_unregister_device(gsm_tty_driver, base + i);
2253 gsm_cleanup_mux(gsm);
2254 tty_kref_put(gsm->tty);
2258 static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2259 char *fp, int count)
2261 struct gsm_mux *gsm = tty->disc_data;
2262 const unsigned char *dp;
2269 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET,
2272 for (i = count, dp = cp, f = fp; i; i--, dp++) {
2276 gsm->receive(gsm, *dp);
2282 gsm->error(gsm, *dp, flags);
2285 WARN_ONCE(1, "%s: unknown flag %d\n",
2286 tty_name(tty, buf), flags);
2290 /* FASYNC if needed ? */
2291 /* If clogged call tty_throttle(tty); */
2295 * gsmld_chars_in_buffer - report available bytes
2298 * Report the number of characters buffered to be delivered to user
2299 * at this instant in time.
2304 static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
2310 * gsmld_flush_buffer - clean input queue
2311 * @tty: terminal device
2313 * Flush the input buffer. Called when the line discipline is
2314 * being closed, when the tty layer wants the buffer flushed (eg
2318 static void gsmld_flush_buffer(struct tty_struct *tty)
2323 * gsmld_close - close the ldisc for this tty
2326 * Called from the terminal layer when this line discipline is
2327 * being shut down, either because of a close or becsuse of a
2328 * discipline change. The function will not be called while other
2329 * ldisc methods are in progress.
2332 static void gsmld_close(struct tty_struct *tty)
2334 struct gsm_mux *gsm = tty->disc_data;
2336 gsmld_detach_gsm(tty, gsm);
2338 gsmld_flush_buffer(tty);
2339 /* Do other clean up here */
2344 * gsmld_open - open an ldisc
2345 * @tty: terminal to open
2347 * Called when this line discipline is being attached to the
2348 * terminal device. Can sleep. Called serialized so that no
2349 * other events will occur in parallel. No further open will occur
2353 static int gsmld_open(struct tty_struct *tty)
2355 struct gsm_mux *gsm;
2357 if (tty->ops->write == NULL)
2360 /* Attach our ldisc data */
2361 gsm = gsm_alloc_mux();
2365 tty->disc_data = gsm;
2366 tty->receive_room = 65536;
2368 /* Attach the initial passive connection */
2370 return gsmld_attach_gsm(tty, gsm);
2374 * gsmld_write_wakeup - asynchronous I/O notifier
2377 * Required for the ptys, serial driver etc. since processes
2378 * that attach themselves to the master and rely on ASYNC
2379 * IO must be woken up
2382 static void gsmld_write_wakeup(struct tty_struct *tty)
2384 struct gsm_mux *gsm = tty->disc_data;
2385 unsigned long flags;
2388 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2389 spin_lock_irqsave(&gsm->tx_lock, flags);
2391 if (gsm->tx_bytes < TX_THRESH_LO) {
2392 gsm_dlci_data_sweep(gsm);
2394 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2398 * gsmld_read - read function for tty
2400 * @file: file object
2401 * @buf: userspace buffer pointer
2404 * Perform reads for the line discipline. We are guaranteed that the
2405 * line discipline will not be closed under us but we may get multiple
2406 * parallel readers and must handle this ourselves. We may also get
2407 * a hangup. Always called in user context, may sleep.
2409 * This code must be sure never to sleep through a hangup.
2412 static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2413 unsigned char __user *buf, size_t nr)
2419 * gsmld_write - write function for tty
2421 * @file: file object
2422 * @buf: userspace buffer pointer
2425 * Called when the owner of the device wants to send a frame
2426 * itself (or some other control data). The data is transferred
2427 * as-is and must be properly framed and checksummed as appropriate
2428 * by userspace. Frames are either sent whole or not at all as this
2429 * avoids pain user side.
2432 static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2433 const unsigned char *buf, size_t nr)
2435 int space = tty_write_room(tty);
2437 return tty->ops->write(tty, buf, nr);
2438 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2443 * gsmld_poll - poll method for N_GSM0710
2444 * @tty: terminal device
2445 * @file: file accessing it
2448 * Called when the line discipline is asked to poll() for data or
2449 * for special events. This code is not serialized with respect to
2450 * other events save open/close.
2452 * This code must be sure never to sleep through a hangup.
2453 * Called without the kernel lock held - fine
2456 static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2459 unsigned int mask = 0;
2460 struct gsm_mux *gsm = tty->disc_data;
2462 poll_wait(file, &tty->read_wait, wait);
2463 poll_wait(file, &tty->write_wait, wait);
2464 if (tty_hung_up_p(file))
2466 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2467 mask |= POLLOUT | POLLWRNORM;
2473 static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2474 struct gsm_config *c)
2477 int need_restart = 0;
2479 /* Stuff we don't support yet - UI or I frame transport, windowing */
2480 if ((c->adaption != 1 && c->adaption != 2) || c->k)
2482 /* Check the MRU/MTU range looks sane */
2483 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2487 if (c->encapsulation > 1) /* Basic, advanced, no I */
2489 if (c->initiator > 1)
2491 if (c->i == 0 || c->i > 2) /* UIH and UI only */
2494 * See what is needed for reconfiguration
2498 if (c->t1 != 0 && c->t1 != gsm->t1)
2500 if (c->t2 != 0 && c->t2 != gsm->t2)
2502 if (c->encapsulation != gsm->encoding)
2504 if (c->adaption != gsm->adaption)
2507 if (c->initiator != gsm->initiator)
2509 if (c->mru != gsm->mru)
2511 if (c->mtu != gsm->mtu)
2515 * Close down what is needed, restart and initiate the new
2519 if (need_close || need_restart) {
2520 gsm_dlci_begin_close(gsm->dlci[0]);
2521 /* This will timeout if the link is down due to N2 expiring */
2522 wait_event_interruptible(gsm->event,
2523 gsm->dlci[0]->state == DLCI_CLOSED);
2524 if (signal_pending(current))
2528 gsm_cleanup_mux(gsm);
2530 gsm->initiator = c->initiator;
2533 gsm->encoding = c->encapsulation;
2534 gsm->adaption = c->adaption;
2547 /* FIXME: We need to separate activation/deactivation from adding
2548 and removing from the mux array */
2550 gsm_activate_mux(gsm);
2551 if (gsm->initiator && need_close)
2552 gsm_dlci_begin_open(gsm->dlci[0]);
2556 static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2557 unsigned int cmd, unsigned long arg)
2559 struct gsm_config c;
2560 struct gsm_mux *gsm = tty->disc_data;
2563 case GSMIOC_GETCONF:
2564 memset(&c, 0, sizeof(c));
2565 c.adaption = gsm->adaption;
2566 c.encapsulation = gsm->encoding;
2567 c.initiator = gsm->initiator;
2570 c.t3 = 0; /* Not supported */
2572 if (gsm->ftype == UIH)
2576 pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
2580 if (copy_to_user((void *)arg, &c, sizeof(c)))
2583 case GSMIOC_SETCONF:
2584 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2586 return gsmld_config(tty, gsm, &c);
2588 return n_tty_ioctl_helper(tty, file, cmd, arg);
2597 static int gsm_mux_net_open(struct net_device *net)
2599 pr_debug("%s called\n", __func__);
2600 netif_start_queue(net);
2604 static int gsm_mux_net_close(struct net_device *net)
2606 netif_stop_queue(net);
2610 static struct net_device_stats *gsm_mux_net_get_stats(struct net_device *net)
2612 return &((struct gsm_mux_net *)netdev_priv(net))->stats;
2614 static void dlci_net_free(struct gsm_dlci *dlci)
2620 dlci->adaption = dlci->prev_adaption;
2621 dlci->data = dlci->prev_data;
2622 free_netdev(dlci->net);
2625 static void net_free(struct kref *ref)
2627 struct gsm_mux_net *mux_net;
2628 struct gsm_dlci *dlci;
2630 mux_net = container_of(ref, struct gsm_mux_net, ref);
2631 dlci = mux_net->dlci;
2634 unregister_netdev(dlci->net);
2635 dlci_net_free(dlci);
2639 static inline void muxnet_get(struct gsm_mux_net *mux_net)
2641 kref_get(&mux_net->ref);
2644 static inline void muxnet_put(struct gsm_mux_net *mux_net)
2646 kref_put(&mux_net->ref, net_free);
2649 static int gsm_mux_net_start_xmit(struct sk_buff *skb,
2650 struct net_device *net)
2652 struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
2653 struct gsm_dlci *dlci = mux_net->dlci;
2654 muxnet_get(mux_net);
2656 skb_queue_head(&dlci->skb_list, skb);
2657 STATS(net).tx_packets++;
2658 STATS(net).tx_bytes += skb->len;
2659 gsm_dlci_data_kick(dlci);
2660 /* And tell the kernel when the last transmit started. */
2661 net->trans_start = jiffies;
2662 muxnet_put(mux_net);
2663 return NETDEV_TX_OK;
2666 /* called when a packet did not ack after watchdogtimeout */
2667 static void gsm_mux_net_tx_timeout(struct net_device *net)
2669 /* Tell syslog we are hosed. */
2670 dev_dbg(&net->dev, "Tx timed out.\n");
2672 /* Update statistics */
2673 STATS(net).tx_errors++;
2676 static void gsm_mux_rx_netchar(struct gsm_dlci *dlci,
2677 unsigned char *in_buf, int size)
2679 struct net_device *net = dlci->net;
2680 struct sk_buff *skb;
2681 struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
2682 muxnet_get(mux_net);
2684 /* Allocate an sk_buff */
2685 skb = dev_alloc_skb(size + NET_IP_ALIGN);
2687 /* We got no receive buffer. */
2688 STATS(net).rx_dropped++;
2689 muxnet_put(mux_net);
2692 skb_reserve(skb, NET_IP_ALIGN);
2693 memcpy(skb_put(skb, size), in_buf, size);
2696 skb->protocol = __constant_htons(ETH_P_IP);
2698 /* Ship it off to the kernel */
2701 /* update out statistics */
2702 STATS(net).rx_packets++;
2703 STATS(net).rx_bytes += size;
2704 muxnet_put(mux_net);
2708 int gsm_change_mtu(struct net_device *net, int new_mtu)
2710 struct gsm_mux_net *mux_net = (struct gsm_mux_net *)netdev_priv(net);
2711 if ((new_mtu < 8) || (new_mtu > mux_net->dlci->gsm->mtu))
2717 static void gsm_mux_net_init(struct net_device *net)
2719 static const struct net_device_ops gsm_netdev_ops = {
2720 .ndo_open = gsm_mux_net_open,
2721 .ndo_stop = gsm_mux_net_close,
2722 .ndo_start_xmit = gsm_mux_net_start_xmit,
2723 .ndo_tx_timeout = gsm_mux_net_tx_timeout,
2724 .ndo_get_stats = gsm_mux_net_get_stats,
2725 .ndo_change_mtu = gsm_change_mtu,
2728 net->netdev_ops = &gsm_netdev_ops;
2730 /* fill in the other fields */
2731 net->watchdog_timeo = GSM_NET_TX_TIMEOUT;
2732 net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
2733 net->type = ARPHRD_NONE;
2734 net->tx_queue_len = 10;
2738 /* caller holds the dlci mutex */
2739 static void gsm_destroy_network(struct gsm_dlci *dlci)
2741 struct gsm_mux_net *mux_net;
2743 pr_debug("destroy network interface");
2746 mux_net = (struct gsm_mux_net *)netdev_priv(dlci->net);
2747 muxnet_put(mux_net);
2751 /* caller holds the dlci mutex */
2752 static int gsm_create_network(struct gsm_dlci *dlci, struct gsm_netconfig *nc)
2756 struct net_device *net;
2757 struct gsm_mux_net *mux_net;
2759 if (!capable(CAP_NET_ADMIN))
2762 /* Already in a non tty mode */
2763 if (dlci->adaption > 2)
2766 if (nc->protocol != htons(ETH_P_IP))
2767 return -EPROTONOSUPPORT;
2769 if (nc->adaption != 3 && nc->adaption != 4)
2770 return -EPROTONOSUPPORT;
2772 pr_debug("create network interface");
2775 if (nc->if_name[0] != '\0')
2776 netname = nc->if_name;
2777 net = alloc_netdev(sizeof(struct gsm_mux_net),
2781 pr_err("alloc_netdev failed");
2784 net->mtu = dlci->gsm->mtu;
2785 mux_net = (struct gsm_mux_net *)netdev_priv(net);
2786 mux_net->dlci = dlci;
2787 kref_init(&mux_net->ref);
2788 strncpy(nc->if_name, net->name, IFNAMSIZ); /* return net name */
2790 /* reconfigure dlci for network */
2791 dlci->prev_adaption = dlci->adaption;
2792 dlci->prev_data = dlci->data;
2793 dlci->adaption = nc->adaption;
2794 dlci->data = gsm_mux_rx_netchar;
2797 pr_debug("register netdev");
2798 retval = register_netdev(net);
2800 pr_err("network register fail %d\n", retval);
2801 dlci_net_free(dlci);
2804 return net->ifindex; /* return network index */
2807 /* Line discipline for real tty */
2808 struct tty_ldisc_ops tty_ldisc_packet = {
2809 .owner = THIS_MODULE,
2810 .magic = TTY_LDISC_MAGIC,
2813 .close = gsmld_close,
2814 .flush_buffer = gsmld_flush_buffer,
2815 .chars_in_buffer = gsmld_chars_in_buffer,
2817 .write = gsmld_write,
2818 .ioctl = gsmld_ioctl,
2820 .receive_buf = gsmld_receive_buf,
2821 .write_wakeup = gsmld_write_wakeup
2830 static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2833 struct gsm_control *ctrl;
2839 modembits[0] = len << 1 | EA; /* Data bytes */
2840 modembits[1] = dlci->addr << 2 | 3; /* DLCI, EA, 1 */
2841 modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2843 modembits[3] = brk << 4 | 2 | EA; /* Valid, EA */
2844 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2847 return gsm_control_wait(dlci->gsm, ctrl);
2850 static int gsm_carrier_raised(struct tty_port *port)
2852 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2853 /* Not yet open so no carrier info */
2854 if (dlci->state != DLCI_OPEN)
2858 return dlci->modem_rx & TIOCM_CD;
2861 static void gsm_dtr_rts(struct tty_port *port, int onoff)
2863 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2864 unsigned int modem_tx = dlci->modem_tx;
2866 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2868 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2869 if (modem_tx != dlci->modem_tx) {
2870 dlci->modem_tx = modem_tx;
2871 gsmtty_modem_update(dlci, 0);
2875 static const struct tty_port_operations gsm_port_ops = {
2876 .carrier_raised = gsm_carrier_raised,
2877 .dtr_rts = gsm_dtr_rts,
2878 .destruct = gsm_dlci_free,
2881 static int gsmtty_install(struct tty_driver *driver, struct tty_struct *tty)
2883 struct gsm_mux *gsm;
2884 struct gsm_dlci *dlci;
2885 unsigned int line = tty->index;
2886 unsigned int mux = line >> 6;
2894 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2895 if (gsm_mux[mux] == NULL)
2897 if (line == 0 || line > 61) /* 62/63 reserved */
2902 /* If DLCI 0 is not yet fully open return an error. This is ok from a locking
2903 perspective as we don't have to worry about this if DLCI0 is lost */
2904 if (gsm->dlci[0] && gsm->dlci[0]->state != DLCI_OPEN)
2906 dlci = gsm->dlci[line];
2909 dlci = gsm_dlci_alloc(gsm, line);
2913 ret = tty_port_install(&dlci->port, driver, tty);
2920 tty->driver_data = dlci;
2925 static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2927 struct gsm_dlci *dlci = tty->driver_data;
2928 struct tty_port *port = &dlci->port;
2932 dlci_get(dlci->gsm->dlci[0]);
2934 tty_port_tty_set(port, tty);
2937 /* We could in theory open and close before we wait - eg if we get
2938 a DM straight back. This is ok as that will have caused a hangup */
2939 set_bit(ASYNCB_INITIALIZED, &port->flags);
2940 /* Start sending off SABM messages */
2941 gsm_dlci_begin_open(dlci);
2942 /* And wait for virtual carrier */
2943 return tty_port_block_til_ready(port, tty, filp);
2946 static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2948 struct gsm_dlci *dlci = tty->driver_data;
2949 struct gsm_mux *gsm;
2953 mutex_lock(&dlci->mutex);
2954 gsm_destroy_network(dlci);
2955 mutex_unlock(&dlci->mutex);
2957 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
2959 gsm_dlci_begin_close(dlci);
2960 tty_port_close_end(&dlci->port, tty);
2961 tty_port_tty_set(&dlci->port, NULL);
2964 dlci_put(gsm->dlci[0]);
2968 static void gsmtty_hangup(struct tty_struct *tty)
2970 struct gsm_dlci *dlci = tty->driver_data;
2971 tty_port_hangup(&dlci->port);
2972 gsm_dlci_begin_close(dlci);
2975 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2978 struct gsm_dlci *dlci = tty->driver_data;
2979 /* Stuff the bytes into the fifo queue */
2980 int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
2981 /* Need to kick the channel */
2982 gsm_dlci_data_kick(dlci);
2986 static int gsmtty_write_room(struct tty_struct *tty)
2988 struct gsm_dlci *dlci = tty->driver_data;
2989 return TX_SIZE - kfifo_len(dlci->fifo);
2992 static int gsmtty_chars_in_buffer(struct tty_struct *tty)
2994 struct gsm_dlci *dlci = tty->driver_data;
2995 return kfifo_len(dlci->fifo);
2998 static void gsmtty_flush_buffer(struct tty_struct *tty)
3000 struct gsm_dlci *dlci = tty->driver_data;
3001 /* Caution needed: If we implement reliable transport classes
3002 then the data being transmitted can't simply be junked once
3003 it has first hit the stack. Until then we can just blow it
3005 kfifo_reset(dlci->fifo);
3006 /* Need to unhook this DLCI from the transmit queue logic */
3009 static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
3011 /* The FIFO handles the queue so the kernel will do the right
3012 thing waiting on chars_in_buffer before calling us. No work
3016 static int gsmtty_tiocmget(struct tty_struct *tty)
3018 struct gsm_dlci *dlci = tty->driver_data;
3019 return dlci->modem_rx;
3022 static int gsmtty_tiocmset(struct tty_struct *tty,
3023 unsigned int set, unsigned int clear)
3025 struct gsm_dlci *dlci = tty->driver_data;
3026 unsigned int modem_tx = dlci->modem_tx;
3031 if (modem_tx != dlci->modem_tx) {
3032 dlci->modem_tx = modem_tx;
3033 return gsmtty_modem_update(dlci, 0);
3039 static int gsmtty_ioctl(struct tty_struct *tty,
3040 unsigned int cmd, unsigned long arg)
3042 struct gsm_dlci *dlci = tty->driver_data;
3043 struct gsm_netconfig nc;
3047 case GSMIOC_ENABLE_NET:
3048 if (copy_from_user(&nc, (void __user *)arg, sizeof(nc)))
3050 nc.if_name[IFNAMSIZ-1] = '\0';
3051 /* return net interface index or error code */
3052 mutex_lock(&dlci->mutex);
3053 index = gsm_create_network(dlci, &nc);
3054 mutex_unlock(&dlci->mutex);
3055 if (copy_to_user((void __user *)arg, &nc, sizeof(nc)))
3058 case GSMIOC_DISABLE_NET:
3059 if (!capable(CAP_NET_ADMIN))
3061 mutex_lock(&dlci->mutex);
3062 gsm_destroy_network(dlci);
3063 mutex_unlock(&dlci->mutex);
3066 return -ENOIOCTLCMD;
3070 static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
3072 /* For the moment its fixed. In actual fact the speed information
3073 for the virtual channel can be propogated in both directions by
3074 the RPN control message. This however rapidly gets nasty as we
3075 then have to remap modem signals each way according to whether
3076 our virtual cable is null modem etc .. */
3077 tty_termios_copy_hw(&tty->termios, old);
3080 static void gsmtty_throttle(struct tty_struct *tty)
3082 struct gsm_dlci *dlci = tty->driver_data;
3083 if (tty->termios.c_cflag & CRTSCTS)
3084 dlci->modem_tx &= ~TIOCM_DTR;
3085 dlci->throttled = 1;
3086 /* Send an MSC with DTR cleared */
3087 gsmtty_modem_update(dlci, 0);
3090 static void gsmtty_unthrottle(struct tty_struct *tty)
3092 struct gsm_dlci *dlci = tty->driver_data;
3093 if (tty->termios.c_cflag & CRTSCTS)
3094 dlci->modem_tx |= TIOCM_DTR;
3095 dlci->throttled = 0;
3096 /* Send an MSC with DTR set */
3097 gsmtty_modem_update(dlci, 0);
3100 static int gsmtty_break_ctl(struct tty_struct *tty, int state)
3102 struct gsm_dlci *dlci = tty->driver_data;
3103 int encode = 0; /* Off */
3105 if (state == -1) /* "On indefinitely" - we can't encode this
3108 else if (state > 0) {
3109 encode = state / 200; /* mS to encoding */
3111 encode = 0x0F; /* Best effort */
3113 return gsmtty_modem_update(dlci, encode);
3117 /* Virtual ttys for the demux */
3118 static const struct tty_operations gsmtty_ops = {
3119 .install = gsmtty_install,
3120 .open = gsmtty_open,
3121 .close = gsmtty_close,
3122 .write = gsmtty_write,
3123 .write_room = gsmtty_write_room,
3124 .chars_in_buffer = gsmtty_chars_in_buffer,
3125 .flush_buffer = gsmtty_flush_buffer,
3126 .ioctl = gsmtty_ioctl,
3127 .throttle = gsmtty_throttle,
3128 .unthrottle = gsmtty_unthrottle,
3129 .set_termios = gsmtty_set_termios,
3130 .hangup = gsmtty_hangup,
3131 .wait_until_sent = gsmtty_wait_until_sent,
3132 .tiocmget = gsmtty_tiocmget,
3133 .tiocmset = gsmtty_tiocmset,
3134 .break_ctl = gsmtty_break_ctl,
3139 static int __init gsm_init(void)
3141 /* Fill in our line protocol discipline, and register it */
3142 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
3144 pr_err("n_gsm: can't register line discipline (err = %d)\n",
3149 gsm_tty_driver = alloc_tty_driver(256);
3150 if (!gsm_tty_driver) {
3151 tty_unregister_ldisc(N_GSM0710);
3152 pr_err("gsm_init: tty allocation failed.\n");
3155 gsm_tty_driver->driver_name = "gsmtty";
3156 gsm_tty_driver->name = "gsmtty";
3157 gsm_tty_driver->major = 0; /* Dynamic */
3158 gsm_tty_driver->minor_start = 0;
3159 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
3160 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
3161 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
3162 | TTY_DRIVER_HARDWARE_BREAK;
3163 gsm_tty_driver->init_termios = tty_std_termios;
3165 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
3166 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
3168 spin_lock_init(&gsm_mux_lock);
3170 if (tty_register_driver(gsm_tty_driver)) {
3171 put_tty_driver(gsm_tty_driver);
3172 tty_unregister_ldisc(N_GSM0710);
3173 pr_err("gsm_init: tty registration failed.\n");
3176 pr_debug("gsm_init: loaded as %d,%d.\n",
3177 gsm_tty_driver->major, gsm_tty_driver->minor_start);
3181 static void __exit gsm_exit(void)
3183 int status = tty_unregister_ldisc(N_GSM0710);
3185 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
3187 tty_unregister_driver(gsm_tty_driver);
3188 put_tty_driver(gsm_tty_driver);
3191 module_init(gsm_init);
3192 module_exit(gsm_exit);
3195 MODULE_LICENSE("GPL");
3196 MODULE_ALIAS_LDISC(N_GSM0710);