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 */
141 #define DLCI_MODE_ABM 0 /* Normal Asynchronous Balanced Mode */
142 #define DLCI_MODE_ADM 1 /* Asynchronous Disconnected Mode */
143 spinlock_t lock; /* Protects the internal state */
144 struct timer_list t1; /* Retransmit timer for SABM and UA */
146 /* Uplink tty if active */
147 struct tty_port port; /* The tty bound to this DLCI if there is one */
148 struct kfifo *fifo; /* Queue fifo for the DLCI */
149 struct kfifo _fifo; /* For new fifo API porting only */
150 int adaption; /* Adaption layer in use */
152 u32 modem_rx; /* Our incoming virtual modem lines */
153 u32 modem_tx; /* Our outgoing modem lines */
154 int dead; /* Refuse re-open */
156 int throttled; /* Private copy of throttle state */
157 int constipated; /* Throttle status for outgoing */
159 struct sk_buff *skb; /* Frame being sent */
160 struct sk_buff_head skb_list; /* Queued frames */
161 /* Data handling callback */
162 void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
163 void (*prev_data)(struct gsm_dlci *dlci, u8 *data, int len);
164 struct net_device *net; /* network interface, if created */
167 /* DLCI 0, 62/63 are special or reserved see gsmtty_open */
172 * DLCI 0 is used to pass control blocks out of band of the data
173 * flow (and with a higher link priority). One command can be outstanding
174 * at a time and we use this structure to manage them. They are created
175 * and destroyed by the user context, and updated by the receive paths
180 u8 cmd; /* Command we are issuing */
181 u8 *data; /* Data for the command in case we retransmit */
182 int len; /* Length of block for retransmission */
183 int done; /* Done flag */
184 int error; /* Error if any */
188 * Each GSM mux we have is represented by this structure. If we are
189 * operating as an ldisc then we use this structure as our ldisc
190 * state. We need to sort out lifetimes and locking with respect
191 * to the gsm mux array. For now we don't free DLCI objects that
192 * have been instantiated until the mux itself is terminated.
194 * To consider further: tty open versus mux shutdown.
198 struct tty_struct *tty; /* The tty our ldisc is bound to */
204 /* Events on the GSM channel */
205 wait_queue_head_t event;
207 /* Bits for GSM mode decoding */
214 #define GSM_ADDRESS 2
215 #define GSM_CONTROL 3
219 #define GSM_OVERRUN 7
224 unsigned int address;
231 u8 *txframe; /* TX framing buffer */
233 /* Methods for the receiver side */
234 void (*receive)(struct gsm_mux *gsm, u8 ch);
235 void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
236 /* And transmit side */
237 int (*output)(struct gsm_mux *mux, u8 *data, int len);
242 int initiator; /* Did we initiate connection */
243 int dead; /* Has the mux been shut down */
244 struct gsm_dlci *dlci[NUM_DLCI];
245 int constipated; /* Asked by remote to shut up */
248 unsigned int tx_bytes; /* TX data outstanding */
249 #define TX_THRESH_HI 8192
250 #define TX_THRESH_LO 2048
251 struct list_head tx_list; /* Pending data packets */
253 /* Control messages */
254 struct timer_list t2_timer; /* Retransmit timer for commands */
255 int cretries; /* Command retry counter */
256 struct gsm_control *pending_cmd;/* Our current pending command */
257 spinlock_t control_lock; /* Protects the pending command */
260 int adaption; /* 1 or 2 supported */
261 u8 ftype; /* UI or UIH */
262 int t1, t2; /* Timers in 1/100th of a sec */
263 int n2; /* Retry count */
265 /* Statistics (not currently exposed) */
266 unsigned long bad_fcs;
267 unsigned long malformed;
268 unsigned long io_error;
269 unsigned long bad_size;
270 unsigned long unsupported;
275 * Mux objects - needed so that we can translate a tty index into the
276 * relevant mux and DLCI.
279 #define MAX_MUX 4 /* 256 minors */
280 static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */
281 static spinlock_t gsm_mux_lock;
283 static struct tty_driver *gsm_tty_driver;
286 * This section of the driver logic implements the GSM encodings
287 * both the basic and the 'advanced'. Reliable transport is not
295 /* I is special: the rest are ..*/
306 /* Channel commands */
308 #define CMD_TEST 0x11
311 #define CMD_FCOFF 0x31
314 #define CMD_FCON 0x51
319 /* Virtual modem bits */
326 #define GSM0_SOF 0xF9
327 #define GSM1_SOF 0x7E
328 #define GSM1_ESCAPE 0x7D
329 #define GSM1_ESCAPE_BITS 0x20
332 #define ISO_IEC_646_MASK 0x7F
334 static const struct tty_port_operations gsm_port_ops;
337 * CRC table for GSM 0710
340 static const u8 gsm_fcs8[256] = {
341 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
342 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
343 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
344 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
345 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
346 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
347 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
348 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
349 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
350 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
351 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
352 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
353 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
354 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
355 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
356 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
357 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
358 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
359 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
360 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
361 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
362 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
363 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
364 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
365 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
366 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
367 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
368 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
369 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
370 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
371 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
372 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
375 #define INIT_FCS 0xFF
376 #define GOOD_FCS 0xCF
379 * gsm_fcs_add - update FCS
383 * Update the FCS to include c. Uses the algorithm in the specification
387 static inline u8 gsm_fcs_add(u8 fcs, u8 c)
389 return gsm_fcs8[fcs ^ c];
393 * gsm_fcs_add_block - update FCS for a block
396 * @len: length of buffer
398 * Update the FCS to include c. Uses the algorithm in the specification
402 static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
405 fcs = gsm_fcs8[fcs ^ *c++];
410 * gsm_read_ea - read a byte into an EA
411 * @val: variable holding value
412 * c: byte going into the EA
414 * Processes one byte of an EA. Updates the passed variable
415 * and returns 1 if the EA is now completely read
418 static int gsm_read_ea(unsigned int *val, u8 c)
420 /* Add the next 7 bits into the value */
423 /* Was this the last byte of the EA 1 = yes*/
428 * gsm_encode_modem - encode modem data bits
429 * @dlci: DLCI to encode from
431 * Returns the correct GSM encoded modem status bits (6 bit field) for
432 * the current status of the DLCI and attached tty object
435 static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
438 /* FC is true flow control not modem bits */
441 if (dlci->modem_tx & TIOCM_DTR)
442 modembits |= MDM_RTC;
443 if (dlci->modem_tx & TIOCM_RTS)
444 modembits |= MDM_RTR;
445 if (dlci->modem_tx & TIOCM_RI)
447 if (dlci->modem_tx & TIOCM_CD || dlci->gsm->initiator)
453 * gsm_print_packet - display a frame for debug
454 * @hdr: header to print before decode
455 * @addr: address EA from the frame
456 * @cr: C/R bit from the frame
457 * @control: control including PF bit
458 * @data: following data bytes
459 * @dlen: length of data
461 * Displays a packet in human readable format for debugging purposes. The
462 * style is based on amateur radio LAP-B dump display.
465 static void gsm_print_packet(const char *hdr, int addr, int cr,
466 u8 control, const u8 *data, int dlen)
471 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
473 switch (control & ~PF) {
493 if (!(control & 0x01)) {
494 pr_cont("I N(S)%d N(R)%d",
495 (control & 0x0E) >> 1, (control & 0xE0) >> 5);
496 } else switch (control & 0x0F) {
498 pr_cont("RR(%d)", (control & 0xE0) >> 5);
501 pr_cont("RNR(%d)", (control & 0xE0) >> 5);
504 pr_cont("REJ(%d)", (control & 0xE0) >> 5);
507 pr_cont("[%02X]", control);
523 pr_cont("%02X ", *data++);
532 * Link level transmission side
536 * gsm_stuff_packet - bytestuff a packet
539 * @len: length of input
541 * Expand a buffer by bytestuffing it. The worst case size change
542 * is doubling and the caller is responsible for handing out
543 * suitable sized buffers.
546 static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
550 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
551 || (*input & ISO_IEC_646_MASK) == XON
552 || (*input & ISO_IEC_646_MASK) == XOFF) {
553 *output++ = GSM1_ESCAPE;
554 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
557 *output++ = *input++;
564 * gsm_send - send a control frame
566 * @addr: address for control frame
567 * @cr: command/response bit
568 * @control: control byte including PF bit
570 * Format up and transmit a control frame. These do not go via the
571 * queueing logic as they should be transmitted ahead of data when
574 * FIXME: Lock versus data TX path
577 static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
583 switch (gsm->encoding) {
586 cbuf[1] = (addr << 2) | (cr << 1) | EA;
588 cbuf[3] = EA; /* Length of data = 0 */
589 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
595 /* Control frame + packing (but not frame stuffing) in mode 1 */
596 ibuf[0] = (addr << 2) | (cr << 1) | EA;
598 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
599 /* Stuffing may double the size worst case */
600 len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
601 /* Now add the SOF markers */
603 cbuf[len + 1] = GSM1_SOF;
604 /* FIXME: we can omit the lead one in many cases */
611 gsm->output(gsm, cbuf, len);
612 gsm_print_packet("-->", addr, cr, control, NULL, 0);
616 * gsm_response - send a control response
618 * @addr: address for control frame
619 * @control: control byte including PF bit
621 * Format up and transmit a link level response frame.
624 static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
626 gsm_send(gsm, addr, 0, control);
630 * gsm_command - send a control command
632 * @addr: address for control frame
633 * @control: control byte including PF bit
635 * Format up and transmit a link level command frame.
638 static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
640 gsm_send(gsm, addr, 1, control);
643 /* Data transmission */
645 #define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
648 * gsm_data_alloc - allocate data frame
650 * @addr: DLCI address
651 * @len: length excluding header and FCS
652 * @ctrl: control byte
654 * Allocate a new data buffer for sending frames with data. Space is left
655 * at the front for header bytes but that is treated as an implementation
656 * detail and not for the high level code to use
659 static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
662 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
666 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */
670 INIT_LIST_HEAD(&m->list);
675 * gsm_data_kick - poke the queue
678 * The tty device has called us to indicate that room has appeared in
679 * the transmit queue. Ram more data into the pipe if we have any
680 * If we have been flow-stopped by a CMD_FCOFF, then we can only
681 * send messages on DLCI0 until CMD_FCON
683 * FIXME: lock against link layer control transmissions
686 static void gsm_data_kick(struct gsm_mux *gsm, struct gsm_dlci *dlci)
688 struct gsm_msg *msg, *nmsg;
691 list_for_each_entry_safe(msg, nmsg, &gsm->tx_list, list) {
692 if (gsm->constipated && msg->addr)
694 if (gsm->encoding != 0) {
695 gsm->txframe[0] = GSM1_SOF;
696 len = gsm_stuff_frame(msg->data,
697 gsm->txframe + 1, msg->len);
698 gsm->txframe[len + 1] = GSM1_SOF;
701 gsm->txframe[0] = GSM0_SOF;
702 memcpy(gsm->txframe + 1 , msg->data, msg->len);
703 gsm->txframe[msg->len + 1] = GSM0_SOF;
708 print_hex_dump_bytes("gsm_data_kick: ",
711 if (gsm->output(gsm, gsm->txframe, len) < 0)
713 /* FIXME: Can eliminate one SOF in many more cases */
714 gsm->tx_bytes -= msg->len;
716 list_del(&msg->list);
720 tty_port_tty_wakeup(&dlci->port);
724 for (i = 0; i < NUM_DLCI; i++)
726 tty_port_tty_wakeup(&gsm->dlci[i]->port);
732 * __gsm_data_queue - queue a UI or UIH frame
733 * @dlci: DLCI sending the data
734 * @msg: message queued
736 * Add data to the transmit queue and try and get stuff moving
737 * out of the mux tty if not already doing so. The Caller must hold
741 static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
743 struct gsm_mux *gsm = dlci->gsm;
745 u8 *fcs = dp + msg->len;
747 /* Fill in the header */
748 if (gsm->encoding == 0) {
750 *--dp = (msg->len << 1) | EA;
752 *--dp = (msg->len >> 7); /* bits 7 - 15 */
753 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */
759 *--dp = (msg->addr << 2) | 2 | EA;
761 *--dp = (msg->addr << 2) | EA;
762 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
763 /* Ugly protocol layering violation */
764 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
765 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
768 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
769 msg->data, msg->len);
771 /* Move the header back and adjust the length, also allow for the FCS
772 now tacked on the end */
773 msg->len += (msg->data - dp) + 1;
776 /* Add to the actual output queue */
777 list_add_tail(&msg->list, &gsm->tx_list);
778 gsm->tx_bytes += msg->len;
779 gsm_data_kick(gsm, dlci);
783 * gsm_data_queue - queue a UI or UIH frame
784 * @dlci: DLCI sending the data
785 * @msg: message queued
787 * Add data to the transmit queue and try and get stuff moving
788 * out of the mux tty if not already doing so. Take the
789 * the gsm tx lock and dlci lock.
792 static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
795 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
796 __gsm_data_queue(dlci, msg);
797 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
801 * gsm_dlci_data_output - try and push data out of a DLCI
803 * @dlci: the DLCI to pull data from
805 * Pull data from a DLCI and send it into the transmit queue if there
806 * is data. Keep to the MRU of the mux. This path handles the usual tty
807 * interface which is a byte stream with optional modem data.
809 * Caller must hold the tx_lock of the mux.
812 static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
816 int len, total_size, size;
817 int h = dlci->adaption - 1;
821 len = kfifo_len(dlci->fifo);
825 /* MTU/MRU count only the data bits */
831 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
832 /* FIXME: need a timer or something to kick this so it can't
833 get stuck with no work outstanding and no buffer free */
837 switch (dlci->adaption) {
838 case 1: /* Unstructured */
840 case 2: /* Unstructed with modem bits.
841 Always one byte as we never send inline break data */
842 *dp++ = gsm_encode_modem(dlci);
845 WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
846 __gsm_data_queue(dlci, msg);
849 /* Bytes of data we used up */
854 * gsm_dlci_data_output_framed - try and push data out of a DLCI
856 * @dlci: the DLCI to pull data from
858 * Pull data from a DLCI and send it into the transmit queue if there
859 * is data. Keep to the MRU of the mux. This path handles framed data
860 * queued as skbuffs to the DLCI.
862 * Caller must hold the tx_lock of the mux.
865 static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
866 struct gsm_dlci *dlci)
871 int last = 0, first = 0;
874 /* One byte per frame is used for B/F flags */
875 if (dlci->adaption == 4)
878 /* dlci->skb is locked by tx_lock */
879 if (dlci->skb == NULL) {
880 dlci->skb = skb_dequeue_tail(&dlci->skb_list);
881 if (dlci->skb == NULL)
885 len = dlci->skb->len + overhead;
887 /* MTU/MRU count only the data bits */
888 if (len > gsm->mtu) {
889 if (dlci->adaption == 3) {
890 /* Over long frame, bin it */
891 dev_kfree_skb_any(dlci->skb);
899 size = len + overhead;
900 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
902 /* FIXME: need a timer or something to kick this so it can't
903 get stuck with no work outstanding and no buffer free */
905 skb_queue_tail(&dlci->skb_list, dlci->skb);
911 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
912 /* Flag byte to carry the start/end info */
913 *dp++ = last << 7 | first << 6 | 1; /* EA */
916 memcpy(dp, dlci->skb->data, len);
917 skb_pull(dlci->skb, len);
918 __gsm_data_queue(dlci, msg);
920 dev_kfree_skb_any(dlci->skb);
927 * gsm_dlci_data_sweep - look for data to send
930 * Sweep the GSM mux channels in priority order looking for ones with
931 * data to send. We could do with optimising this scan a bit. We aim
932 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
933 * TX_THRESH_LO we get called again
935 * FIXME: We should round robin between groups and in theory you can
936 * renegotiate DLCI priorities with optional stuff. Needs optimising.
939 static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
942 /* Priority ordering: We should do priority with RR of the groups */
945 while (i < NUM_DLCI) {
946 struct gsm_dlci *dlci;
948 if (gsm->tx_bytes > TX_THRESH_HI)
951 if (dlci == NULL || dlci->constipated) {
955 if (dlci->adaption < 3 && !dlci->net)
956 len = gsm_dlci_data_output(gsm, dlci);
958 len = gsm_dlci_data_output_framed(gsm, dlci);
961 /* DLCI empty - try the next */
968 * gsm_dlci_data_kick - transmit if possible
969 * @dlci: DLCI to kick
971 * Transmit data from this DLCI if the queue is empty. We can't rely on
972 * a tty wakeup except when we filled the pipe so we need to fire off
973 * new data ourselves in other cases.
976 static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
981 if (dlci->constipated)
984 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
985 /* If we have nothing running then we need to fire up */
986 sweep = (dlci->gsm->tx_bytes < TX_THRESH_LO);
987 if (dlci->gsm->tx_bytes == 0) {
989 gsm_dlci_data_output_framed(dlci->gsm, dlci);
991 gsm_dlci_data_output(dlci->gsm, dlci);
994 gsm_dlci_data_sweep(dlci->gsm);
995 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
999 * Control message processing
1004 * gsm_control_reply - send a response frame to a control
1006 * @cmd: the command to use
1007 * @data: data to follow encoded info
1008 * @dlen: length of data
1010 * Encode up and queue a UI/UIH frame containing our response.
1013 static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
1016 struct gsm_msg *msg;
1017 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
1020 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */
1021 msg->data[1] = (dlen << 1) | EA;
1022 memcpy(msg->data + 2, data, dlen);
1023 gsm_data_queue(gsm->dlci[0], msg);
1027 * gsm_process_modem - process received modem status
1028 * @tty: virtual tty bound to the DLCI
1029 * @dlci: DLCI to affect
1030 * @modem: modem bits (full EA)
1032 * Used when a modem control message or line state inline in adaption
1033 * layer 2 is processed. Sort out the local modem state and throttles
1036 static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
1037 u32 modem, int clen)
1043 /* The modem status command can either contain one octet (v.24 signals)
1044 or two octets (v.24 signals + break signals). The length field will
1045 either be 2 or 3 respectively. This is specified in section
1046 5.4.6.3.7 of the 27.010 mux spec. */
1049 modem = modem & 0x7f;
1052 modem = (modem >> 7) & 0x7f;
1055 /* Flow control/ready to communicate */
1056 fc = (modem & MDM_FC) || !(modem & MDM_RTR);
1057 if (fc && !dlci->constipated) {
1058 /* Need to throttle our output on this device */
1059 dlci->constipated = 1;
1060 } else if (!fc && dlci->constipated) {
1061 dlci->constipated = 0;
1062 gsm_dlci_data_kick(dlci);
1065 /* Map modem bits */
1066 if (modem & MDM_RTC)
1067 mlines |= TIOCM_DSR | TIOCM_DTR;
1068 if (modem & MDM_RTR)
1069 mlines |= TIOCM_RTS | TIOCM_CTS;
1075 /* Carrier drop -> hangup */
1077 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1082 tty_insert_flip_char(&dlci->port, 0, TTY_BREAK);
1083 dlci->modem_rx = mlines;
1087 * gsm_control_modem - modem status received
1089 * @data: data following command
1090 * @clen: command length
1092 * We have received a modem status control message. This is used by
1093 * the GSM mux protocol to pass virtual modem line status and optionally
1094 * to indicate break signals. Unpack it, convert to Linux representation
1095 * and if need be stuff a break message down the tty.
1098 static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1100 unsigned int addr = 0;
1101 unsigned int modem = 0;
1102 unsigned int brk = 0;
1103 struct gsm_dlci *dlci;
1106 struct tty_struct *tty;
1108 while (gsm_read_ea(&addr, *dp++) == 0) {
1113 /* Must be at least one byte following the EA */
1119 /* Closed port, or invalid ? */
1120 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1122 dlci = gsm->dlci[addr];
1124 while (gsm_read_ea(&modem, *dp++) == 0) {
1131 while (gsm_read_ea(&brk, *dp++) == 0) {
1137 modem |= (brk & 0x7f);
1139 tty = tty_port_tty_get(&dlci->port);
1140 gsm_process_modem(tty, dlci, modem, clen);
1145 gsm_control_reply(gsm, CMD_MSC, data, clen);
1149 * gsm_control_rls - remote line status
1152 * @clen: data length
1154 * The modem sends us a two byte message on the control channel whenever
1155 * it wishes to send us an error state from the virtual link. Stuff
1156 * this into the uplink tty if present
1159 static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1161 struct tty_port *port;
1162 unsigned int addr = 0;
1167 while (gsm_read_ea(&addr, *dp++) == 0) {
1172 /* Must be at least one byte following ea */
1177 /* Closed port, or invalid ? */
1178 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1182 if ((bits & 1) == 0)
1185 port = &gsm->dlci[addr]->port;
1188 tty_insert_flip_char(port, 0, TTY_OVERRUN);
1190 tty_insert_flip_char(port, 0, TTY_PARITY);
1192 tty_insert_flip_char(port, 0, TTY_FRAME);
1194 tty_flip_buffer_push(port);
1196 gsm_control_reply(gsm, CMD_RLS, data, clen);
1199 static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1202 * gsm_control_message - DLCI 0 control processing
1204 * @command: the command EA
1205 * @data: data beyond the command/length EAs
1208 * Input processor for control messages from the other end of the link.
1209 * Processes the incoming request and queues a response frame or an
1210 * NSC response if not supported
1213 static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1217 unsigned long flags;
1221 struct gsm_dlci *dlci = gsm->dlci[0];
1222 /* Modem wishes to close down */
1226 gsm_dlci_begin_close(dlci);
1231 /* Modem wishes to test, reply with the data */
1232 gsm_control_reply(gsm, CMD_TEST, data, clen);
1235 /* Modem can accept data again */
1236 gsm->constipated = 0;
1237 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1238 /* Kick the link in case it is idling */
1239 spin_lock_irqsave(&gsm->tx_lock, flags);
1240 gsm_data_kick(gsm, NULL);
1241 spin_unlock_irqrestore(&gsm->tx_lock, flags);
1244 /* Modem wants us to STFU */
1245 gsm->constipated = 1;
1246 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1249 /* Out of band modem line change indicator for a DLCI */
1250 gsm_control_modem(gsm, data, clen);
1253 /* Out of band error reception for a DLCI */
1254 gsm_control_rls(gsm, data, clen);
1257 /* Modem wishes to enter power saving state */
1258 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1260 /* Optional unsupported commands */
1261 case CMD_PN: /* Parameter negotiation */
1262 case CMD_RPN: /* Remote port negotiation */
1263 case CMD_SNC: /* Service negotiation command */
1265 /* Reply to bad commands with an NSC */
1267 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1273 * gsm_control_response - process a response to our control
1275 * @command: the command (response) EA
1276 * @data: data beyond the command/length EA
1279 * Process a response to an outstanding command. We only allow a single
1280 * control message in flight so this is fairly easy. All the clean up
1281 * is done by the caller, we just update the fields, flag it as done
1285 static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1288 struct gsm_control *ctrl;
1289 unsigned long flags;
1291 spin_lock_irqsave(&gsm->control_lock, flags);
1293 ctrl = gsm->pending_cmd;
1294 /* Does the reply match our command */
1296 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1297 /* Our command was replied to, kill the retry timer */
1298 del_timer(&gsm->t2_timer);
1299 gsm->pending_cmd = NULL;
1300 /* Rejected by the other end */
1301 if (command == CMD_NSC)
1302 ctrl->error = -EOPNOTSUPP;
1304 wake_up(&gsm->event);
1306 spin_unlock_irqrestore(&gsm->control_lock, flags);
1310 * gsm_control_transmit - send control packet
1312 * @ctrl: frame to send
1314 * Send out a pending control command (called under control lock)
1317 static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1319 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype);
1322 msg->data[0] = (ctrl->cmd << 1) | 2 | EA; /* command */
1323 memcpy(msg->data + 1, ctrl->data, ctrl->len);
1324 gsm_data_queue(gsm->dlci[0], msg);
1328 * gsm_control_retransmit - retransmit a control frame
1329 * @data: pointer to our gsm object
1331 * Called off the T2 timer expiry in order to retransmit control frames
1332 * that have been lost in the system somewhere. The control_lock protects
1333 * us from colliding with another sender or a receive completion event.
1334 * In that situation the timer may still occur in a small window but
1335 * gsm->pending_cmd will be NULL and we just let the timer expire.
1338 static void gsm_control_retransmit(unsigned long data)
1340 struct gsm_mux *gsm = (struct gsm_mux *)data;
1341 struct gsm_control *ctrl;
1342 unsigned long flags;
1343 spin_lock_irqsave(&gsm->control_lock, flags);
1344 ctrl = gsm->pending_cmd;
1347 if (gsm->cretries == 0) {
1348 gsm->pending_cmd = NULL;
1349 ctrl->error = -ETIMEDOUT;
1351 spin_unlock_irqrestore(&gsm->control_lock, flags);
1352 wake_up(&gsm->event);
1355 gsm_control_transmit(gsm, ctrl);
1356 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1358 spin_unlock_irqrestore(&gsm->control_lock, flags);
1362 * gsm_control_send - send a control frame on DLCI 0
1363 * @gsm: the GSM channel
1364 * @command: command to send including CR bit
1365 * @data: bytes of data (must be kmalloced)
1366 * @len: length of the block to send
1368 * Queue and dispatch a control command. Only one command can be
1369 * active at a time. In theory more can be outstanding but the matching
1370 * gets really complicated so for now stick to one outstanding.
1373 static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1374 unsigned int command, u8 *data, int clen)
1376 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1378 unsigned long flags;
1382 wait_event(gsm->event, gsm->pending_cmd == NULL);
1383 spin_lock_irqsave(&gsm->control_lock, flags);
1384 if (gsm->pending_cmd != NULL) {
1385 spin_unlock_irqrestore(&gsm->control_lock, flags);
1388 ctrl->cmd = command;
1391 gsm->pending_cmd = ctrl;
1393 /* If DLCI0 is in ADM mode skip retries, it won't respond */
1394 if (gsm->dlci[0]->mode == DLCI_MODE_ADM)
1397 gsm->cretries = gsm->n2;
1399 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1400 gsm_control_transmit(gsm, ctrl);
1401 spin_unlock_irqrestore(&gsm->control_lock, flags);
1406 * gsm_control_wait - wait for a control to finish
1408 * @control: control we are waiting on
1410 * Waits for the control to complete or time out. Frees any used
1411 * resources and returns 0 for success, or an error if the remote
1412 * rejected or ignored the request.
1415 static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1418 wait_event(gsm->event, control->done == 1);
1419 err = control->error;
1426 * DLCI level handling: Needs krefs
1430 * State transitions and timers
1434 * gsm_dlci_close - a DLCI has closed
1435 * @dlci: DLCI that closed
1437 * Perform processing when moving a DLCI into closed state. If there
1438 * is an attached tty this is hung up
1441 static void gsm_dlci_close(struct gsm_dlci *dlci)
1443 del_timer(&dlci->t1);
1445 pr_debug("DLCI %d goes closed.\n", dlci->addr);
1446 dlci->state = DLCI_CLOSED;
1447 if (dlci->addr != 0) {
1448 tty_port_tty_hangup(&dlci->port, false);
1449 kfifo_reset(dlci->fifo);
1451 dlci->gsm->dead = 1;
1452 wake_up(&dlci->gsm->event);
1453 /* A DLCI 0 close is a MUX termination so we need to kick that
1454 back to userspace somehow */
1458 * gsm_dlci_open - a DLCI has opened
1459 * @dlci: DLCI that opened
1461 * Perform processing when moving a DLCI into open state.
1464 static void gsm_dlci_open(struct gsm_dlci *dlci)
1466 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1468 del_timer(&dlci->t1);
1469 /* This will let a tty open continue */
1470 dlci->state = DLCI_OPEN;
1472 pr_debug("DLCI %d goes open.\n", dlci->addr);
1473 wake_up(&dlci->gsm->event);
1477 * gsm_dlci_t1 - T1 timer expiry
1478 * @dlci: DLCI that opened
1480 * The T1 timer handles retransmits of control frames (essentially of
1481 * SABM and DISC). We resend the command until the retry count runs out
1482 * in which case an opening port goes back to closed and a closing port
1483 * is simply put into closed state (any further frames from the other
1484 * end will get a DM response)
1486 * Some control dlci can stay in ADM mode with other dlci working just
1487 * fine. In that case we can just keep the control dlci open after the
1488 * DLCI_OPENING retries time out.
1491 static void gsm_dlci_t1(unsigned long data)
1493 struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1494 struct gsm_mux *gsm = dlci->gsm;
1496 switch (dlci->state) {
1499 if (dlci->retries) {
1500 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1501 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1502 } else if (!dlci->addr && gsm->control == (DM | PF)) {
1504 pr_info("DLCI %d opening in ADM mode.\n",
1506 dlci->mode = DLCI_MODE_ADM;
1507 gsm_dlci_open(dlci);
1509 gsm_dlci_begin_close(dlci); /* prevent half open link */
1515 if (dlci->retries) {
1516 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1517 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1519 gsm_dlci_close(dlci);
1525 * gsm_dlci_begin_open - start channel open procedure
1526 * @dlci: DLCI to open
1528 * Commence opening a DLCI from the Linux side. We issue SABM messages
1529 * to the modem which should then reply with a UA or ADM, at which point
1530 * we will move into open state. Opening is done asynchronously with retry
1531 * running off timers and the responses.
1534 static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1536 struct gsm_mux *gsm = dlci->gsm;
1537 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1539 dlci->retries = gsm->n2;
1540 dlci->state = DLCI_OPENING;
1541 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1542 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1546 * gsm_dlci_begin_close - start channel open procedure
1547 * @dlci: DLCI to open
1549 * Commence closing a DLCI from the Linux side. We issue DISC messages
1550 * to the modem which should then reply with a UA, at which point we
1551 * will move into closed state. Closing is done asynchronously with retry
1552 * off timers. We may also receive a DM reply from the other end which
1553 * indicates the channel was already closed.
1556 static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1558 struct gsm_mux *gsm = dlci->gsm;
1559 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1561 dlci->retries = gsm->n2;
1562 dlci->state = DLCI_CLOSING;
1563 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1564 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1568 * gsm_dlci_data - data arrived
1570 * @data: block of bytes received
1571 * @len: length of received block
1573 * A UI or UIH frame has arrived which contains data for a channel
1574 * other than the control channel. If the relevant virtual tty is
1575 * open we shovel the bits down it, if not we drop them.
1578 static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int clen)
1581 struct tty_port *port = &dlci->port;
1582 struct tty_struct *tty;
1583 unsigned int modem = 0;
1587 pr_debug("%d bytes for tty\n", len);
1588 switch (dlci->adaption) {
1589 /* Unsupported types */
1590 /* Packetised interruptible data */
1593 /* Packetised uininterruptible voice/data */
1596 /* Asynchronous serial with line state in each frame */
1598 while (gsm_read_ea(&modem, *data++) == 0) {
1603 tty = tty_port_tty_get(port);
1605 gsm_process_modem(tty, dlci, modem, clen);
1608 /* Line state will go via DLCI 0 controls only */
1611 tty_insert_flip_string(port, data, len);
1612 tty_flip_buffer_push(port);
1617 * gsm_dlci_control - data arrived on control channel
1619 * @data: block of bytes received
1620 * @len: length of received block
1622 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1623 * control channel. This should contain a command EA followed by
1624 * control data bytes. The command EA contains a command/response bit
1625 * and we divide up the work accordingly.
1628 static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1630 /* See what command is involved */
1631 unsigned int command = 0;
1633 if (gsm_read_ea(&command, *data++) == 1) {
1636 /* FIXME: this is properly an EA */
1638 /* Malformed command ? */
1642 gsm_control_message(dlci->gsm, command,
1645 gsm_control_response(dlci->gsm, command,
1653 * Allocate/Free DLCI channels
1657 * gsm_dlci_alloc - allocate a DLCI
1659 * @addr: address of the DLCI
1661 * Allocate and install a new DLCI object into the GSM mux.
1663 * FIXME: review locking races
1666 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1668 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1671 spin_lock_init(&dlci->lock);
1672 mutex_init(&dlci->mutex);
1673 dlci->fifo = &dlci->_fifo;
1674 if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1679 skb_queue_head_init(&dlci->skb_list);
1680 init_timer(&dlci->t1);
1681 dlci->t1.function = gsm_dlci_t1;
1682 dlci->t1.data = (unsigned long)dlci;
1683 tty_port_init(&dlci->port);
1684 dlci->port.ops = &gsm_port_ops;
1687 dlci->adaption = gsm->adaption;
1688 dlci->state = DLCI_CLOSED;
1690 dlci->data = gsm_dlci_data;
1692 dlci->data = gsm_dlci_command;
1693 gsm->dlci[addr] = dlci;
1698 * gsm_dlci_free - free DLCI
1699 * @dlci: DLCI to free
1705 static void gsm_dlci_free(struct tty_port *port)
1707 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
1709 del_timer_sync(&dlci->t1);
1710 dlci->gsm->dlci[dlci->addr] = NULL;
1711 kfifo_free(dlci->fifo);
1712 while ((dlci->skb = skb_dequeue(&dlci->skb_list)))
1713 dev_kfree_skb(dlci->skb);
1717 static inline void dlci_get(struct gsm_dlci *dlci)
1719 tty_port_get(&dlci->port);
1722 static inline void dlci_put(struct gsm_dlci *dlci)
1724 tty_port_put(&dlci->port);
1727 static void gsm_destroy_network(struct gsm_dlci *dlci);
1730 * gsm_dlci_release - release DLCI
1731 * @dlci: DLCI to destroy
1733 * Release a DLCI. Actual free is deferred until either
1734 * mux is closed or tty is closed - whichever is last.
1738 static void gsm_dlci_release(struct gsm_dlci *dlci)
1740 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1742 mutex_lock(&dlci->mutex);
1743 gsm_destroy_network(dlci);
1744 mutex_unlock(&dlci->mutex);
1748 tty_port_tty_set(&dlci->port, NULL);
1751 dlci->state = DLCI_CLOSED;
1756 * LAPBish link layer logic
1760 * gsm_queue - a GSM frame is ready to process
1761 * @gsm: pointer to our gsm mux
1763 * At this point in time a frame has arrived and been demangled from
1764 * the line encoding. All the differences between the encodings have
1765 * been handled below us and the frame is unpacked into the structures.
1766 * The fcs holds the header FCS but any data FCS must be added here.
1769 static void gsm_queue(struct gsm_mux *gsm)
1771 struct gsm_dlci *dlci;
1774 /* We have to sneak a look at the packet body to do the FCS.
1775 A somewhat layering violation in the spec */
1777 if ((gsm->control & ~PF) == UI)
1778 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1779 if (gsm->encoding == 0) {
1780 /* WARNING: gsm->received_fcs is used for
1781 gsm->encoding = 0 only.
1782 In this case it contain the last piece of data
1783 required to generate final CRC */
1784 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1786 if (gsm->fcs != GOOD_FCS) {
1789 pr_debug("BAD FCS %02x\n", gsm->fcs);
1792 address = gsm->address >> 1;
1793 if (address >= NUM_DLCI)
1796 cr = gsm->address & 1; /* C/R bit */
1798 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1800 cr ^= 1 - gsm->initiator; /* Flip so 1 always means command */
1801 dlci = gsm->dlci[address];
1803 switch (gsm->control) {
1808 dlci = gsm_dlci_alloc(gsm, address);
1812 gsm_response(gsm, address, DM);
1814 gsm_response(gsm, address, UA);
1815 gsm_dlci_open(dlci);
1821 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1822 gsm_response(gsm, address, DM);
1825 /* Real close complete */
1826 gsm_response(gsm, address, UA);
1827 gsm_dlci_close(dlci);
1831 if (cr == 0 || dlci == NULL)
1833 switch (dlci->state) {
1835 gsm_dlci_close(dlci);
1838 gsm_dlci_open(dlci);
1842 case DM: /* DM can be valid unsolicited */
1848 gsm_dlci_close(dlci);
1858 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1859 gsm_command(gsm, address, DM|PF);
1862 dlci->data(dlci, gsm->buf, gsm->len);
1875 * gsm0_receive - perform processing for non-transparency
1876 * @gsm: gsm data for this ldisc instance
1879 * Receive bytes in gsm mode 0
1882 static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1886 switch (gsm->state) {
1887 case GSM_SEARCH: /* SOF marker */
1888 if (c == GSM0_SOF) {
1889 gsm->state = GSM_ADDRESS;
1892 gsm->fcs = INIT_FCS;
1895 case GSM_ADDRESS: /* Address EA */
1896 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1897 if (gsm_read_ea(&gsm->address, c))
1898 gsm->state = GSM_CONTROL;
1900 case GSM_CONTROL: /* Control Byte */
1901 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1903 gsm->state = GSM_LEN0;
1905 case GSM_LEN0: /* Length EA */
1906 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1907 if (gsm_read_ea(&gsm->len, c)) {
1908 if (gsm->len > gsm->mru) {
1910 gsm->state = GSM_SEARCH;
1915 gsm->state = GSM_FCS;
1917 gsm->state = GSM_DATA;
1920 gsm->state = GSM_LEN1;
1923 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1925 gsm->len |= len << 7;
1926 if (gsm->len > gsm->mru) {
1928 gsm->state = GSM_SEARCH;
1933 gsm->state = GSM_FCS;
1935 gsm->state = GSM_DATA;
1937 case GSM_DATA: /* Data */
1938 gsm->buf[gsm->count++] = c;
1939 if (gsm->count == gsm->len)
1940 gsm->state = GSM_FCS;
1942 case GSM_FCS: /* FCS follows the packet */
1943 gsm->received_fcs = c;
1945 gsm->state = GSM_SSOF;
1948 if (c == GSM0_SOF) {
1949 gsm->state = GSM_SEARCH;
1957 * gsm1_receive - perform processing for non-transparency
1958 * @gsm: gsm data for this ldisc instance
1961 * Receive bytes in mode 1 (Advanced option)
1964 static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1966 if (c == GSM1_SOF) {
1967 /* EOF is only valid in frame if we have got to the data state
1968 and received at least one byte (the FCS) */
1969 if (gsm->state == GSM_DATA && gsm->count) {
1970 /* Extract the FCS */
1972 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1973 gsm->len = gsm->count;
1975 gsm->state = GSM_START;
1978 /* Any partial frame was a runt so go back to start */
1979 if (gsm->state != GSM_START) {
1981 gsm->state = GSM_START;
1983 /* A SOF in GSM_START means we are still reading idling or
1988 if (c == GSM1_ESCAPE) {
1993 /* Only an unescaped SOF gets us out of GSM search */
1994 if (gsm->state == GSM_SEARCH)
1998 c ^= GSM1_ESCAPE_BITS;
2001 switch (gsm->state) {
2002 case GSM_START: /* First byte after SOF */
2004 gsm->state = GSM_ADDRESS;
2005 gsm->fcs = INIT_FCS;
2007 case GSM_ADDRESS: /* Address continuation */
2008 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
2009 if (gsm_read_ea(&gsm->address, c))
2010 gsm->state = GSM_CONTROL;
2012 case GSM_CONTROL: /* Control Byte */
2013 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
2016 gsm->state = GSM_DATA;
2018 case GSM_DATA: /* Data */
2019 if (gsm->count > gsm->mru) { /* Allow one for the FCS */
2020 gsm->state = GSM_OVERRUN;
2023 gsm->buf[gsm->count++] = c;
2025 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */
2031 * gsm_error - handle tty error
2033 * @data: byte received (may be invalid)
2034 * @flag: error received
2036 * Handle an error in the receipt of data for a frame. Currently we just
2037 * go back to hunting for a SOF.
2039 * FIXME: better diagnostics ?
2042 static void gsm_error(struct gsm_mux *gsm,
2043 unsigned char data, unsigned char flag)
2045 gsm->state = GSM_SEARCH;
2050 * gsm_cleanup_mux - generic GSM protocol cleanup
2053 * Clean up the bits of the mux which are the same for all framing
2054 * protocols. Remove the mux from the mux table, stop all the timers
2055 * and then shut down each device hanging up the channels as we go.
2058 static void gsm_cleanup_mux(struct gsm_mux *gsm)
2061 struct gsm_dlci *dlci = gsm->dlci[0];
2062 struct gsm_msg *txq, *ntxq;
2063 struct gsm_control *gc;
2067 spin_lock(&gsm_mux_lock);
2068 for (i = 0; i < MAX_MUX; i++) {
2069 if (gsm_mux[i] == gsm) {
2074 spin_unlock(&gsm_mux_lock);
2075 /* open failed before registering => nothing to do */
2079 /* In theory disconnecting DLCI 0 is sufficient but for some
2080 modems this is apparently not the case. */
2082 gc = gsm_control_send(gsm, CMD_CLD, NULL, 0);
2084 gsm_control_wait(gsm, gc);
2086 del_timer_sync(&gsm->t2_timer);
2087 /* Now we are sure T2 has stopped */
2090 gsm_dlci_begin_close(dlci);
2091 wait_event_interruptible(gsm->event,
2092 dlci->state == DLCI_CLOSED);
2094 /* Free up any link layer users */
2095 mutex_lock(&gsm->mutex);
2096 for (i = 0; i < NUM_DLCI; i++)
2098 gsm_dlci_release(gsm->dlci[i]);
2099 mutex_unlock(&gsm->mutex);
2100 /* Now wipe the queues */
2101 list_for_each_entry_safe(txq, ntxq, &gsm->tx_list, list)
2103 INIT_LIST_HEAD(&gsm->tx_list);
2107 * gsm_activate_mux - generic GSM setup
2110 * Set up the bits of the mux which are the same for all framing
2111 * protocols. Add the mux to the mux table so it can be opened and
2112 * finally kick off connecting to DLCI 0 on the modem.
2115 static int gsm_activate_mux(struct gsm_mux *gsm)
2117 struct gsm_dlci *dlci;
2120 setup_timer(&gsm->t2_timer, gsm_control_retransmit, (unsigned long)gsm);
2121 init_waitqueue_head(&gsm->event);
2122 spin_lock_init(&gsm->control_lock);
2123 spin_lock_init(&gsm->tx_lock);
2125 if (gsm->encoding == 0)
2126 gsm->receive = gsm0_receive;
2128 gsm->receive = gsm1_receive;
2129 gsm->error = gsm_error;
2131 spin_lock(&gsm_mux_lock);
2132 for (i = 0; i < MAX_MUX; i++) {
2133 if (gsm_mux[i] == NULL) {
2139 spin_unlock(&gsm_mux_lock);
2143 dlci = gsm_dlci_alloc(gsm, 0);
2146 gsm->dead = 0; /* Tty opens are now permissible */
2151 * gsm_free_mux - free up a mux
2154 * Dispose of allocated resources for a dead mux
2156 static void gsm_free_mux(struct gsm_mux *gsm)
2158 kfree(gsm->txframe);
2164 * gsm_free_muxr - free up a mux
2167 * Dispose of allocated resources for a dead mux
2169 static void gsm_free_muxr(struct kref *ref)
2171 struct gsm_mux *gsm = container_of(ref, struct gsm_mux, ref);
2175 static inline void mux_get(struct gsm_mux *gsm)
2177 kref_get(&gsm->ref);
2180 static inline void mux_put(struct gsm_mux *gsm)
2182 kref_put(&gsm->ref, gsm_free_muxr);
2186 * gsm_alloc_mux - allocate a mux
2188 * Creates a new mux ready for activation.
2191 static struct gsm_mux *gsm_alloc_mux(void)
2193 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2196 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2197 if (gsm->buf == NULL) {
2201 gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2202 if (gsm->txframe == NULL) {
2207 spin_lock_init(&gsm->lock);
2208 mutex_init(&gsm->mutex);
2209 kref_init(&gsm->ref);
2210 INIT_LIST_HEAD(&gsm->tx_list);
2218 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
2220 gsm->dead = 1; /* Avoid early tty opens */
2226 * gsmld_output - write to link
2228 * @data: bytes to output
2231 * Write a block of data from the GSM mux to the data channel. This
2232 * will eventually be serialized from above but at the moment isn't.
2235 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2237 if (tty_write_room(gsm->tty) < len) {
2238 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2242 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET,
2244 gsm->tty->ops->write(gsm->tty, data, len);
2249 * gsmld_attach_gsm - mode set up
2250 * @tty: our tty structure
2253 * Set up the MUX for basic mode and commence connecting to the
2254 * modem. Currently called from the line discipline set up but
2255 * will need moving to an ioctl path.
2258 static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2262 gsm->tty = tty_kref_get(tty);
2263 gsm->output = gsmld_output;
2264 ret = gsm_activate_mux(gsm);
2266 tty_kref_put(gsm->tty);
2268 /* Don't register device 0 - this is the control channel and not
2269 a usable tty interface */
2270 base = gsm->num << 6; /* Base for this MUX */
2271 for (i = 1; i < NUM_DLCI; i++)
2272 tty_register_device(gsm_tty_driver, base + i, NULL);
2279 * gsmld_detach_gsm - stop doing 0710 mux
2280 * @tty: tty attached to the mux
2283 * Shutdown and then clean up the resources used by the line discipline
2286 static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2289 int base = gsm->num << 6; /* Base for this MUX */
2291 WARN_ON(tty != gsm->tty);
2292 for (i = 1; i < NUM_DLCI; i++)
2293 tty_unregister_device(gsm_tty_driver, base + i);
2294 gsm_cleanup_mux(gsm);
2295 tty_kref_put(gsm->tty);
2299 static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2300 char *fp, int count)
2302 struct gsm_mux *gsm = tty->disc_data;
2303 const unsigned char *dp;
2306 char flags = TTY_NORMAL;
2309 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET,
2312 for (i = count, dp = cp, f = fp; i; i--, dp++) {
2317 gsm->receive(gsm, *dp);
2323 gsm->error(gsm, *dp, flags);
2326 WARN_ONCE(1, "%s: unknown flag %d\n",
2327 tty_name(tty), flags);
2331 /* FASYNC if needed ? */
2332 /* If clogged call tty_throttle(tty); */
2336 * gsmld_flush_buffer - clean input queue
2337 * @tty: terminal device
2339 * Flush the input buffer. Called when the line discipline is
2340 * being closed, when the tty layer wants the buffer flushed (eg
2344 static void gsmld_flush_buffer(struct tty_struct *tty)
2349 * gsmld_close - close the ldisc for this tty
2352 * Called from the terminal layer when this line discipline is
2353 * being shut down, either because of a close or becsuse of a
2354 * discipline change. The function will not be called while other
2355 * ldisc methods are in progress.
2358 static void gsmld_close(struct tty_struct *tty)
2360 struct gsm_mux *gsm = tty->disc_data;
2362 gsmld_detach_gsm(tty, gsm);
2364 gsmld_flush_buffer(tty);
2365 /* Do other clean up here */
2370 * gsmld_open - open an ldisc
2371 * @tty: terminal to open
2373 * Called when this line discipline is being attached to the
2374 * terminal device. Can sleep. Called serialized so that no
2375 * other events will occur in parallel. No further open will occur
2379 static int gsmld_open(struct tty_struct *tty)
2381 struct gsm_mux *gsm;
2384 if (tty->ops->write == NULL)
2387 /* Attach our ldisc data */
2388 gsm = gsm_alloc_mux();
2392 tty->disc_data = gsm;
2393 tty->receive_room = 65536;
2395 /* Attach the initial passive connection */
2398 ret = gsmld_attach_gsm(tty, gsm);
2400 gsm_cleanup_mux(gsm);
2407 * gsmld_write_wakeup - asynchronous I/O notifier
2410 * Required for the ptys, serial driver etc. since processes
2411 * that attach themselves to the master and rely on ASYNC
2412 * IO must be woken up
2415 static void gsmld_write_wakeup(struct tty_struct *tty)
2417 struct gsm_mux *gsm = tty->disc_data;
2418 unsigned long flags;
2421 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2422 spin_lock_irqsave(&gsm->tx_lock, flags);
2423 gsm_data_kick(gsm, NULL);
2424 if (gsm->tx_bytes < TX_THRESH_LO) {
2425 gsm_dlci_data_sweep(gsm);
2427 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2431 * gsmld_read - read function for tty
2433 * @file: file object
2434 * @buf: userspace buffer pointer
2437 * Perform reads for the line discipline. We are guaranteed that the
2438 * line discipline will not be closed under us but we may get multiple
2439 * parallel readers and must handle this ourselves. We may also get
2440 * a hangup. Always called in user context, may sleep.
2442 * This code must be sure never to sleep through a hangup.
2445 static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2446 unsigned char __user *buf, size_t nr)
2452 * gsmld_write - write function for tty
2454 * @file: file object
2455 * @buf: userspace buffer pointer
2458 * Called when the owner of the device wants to send a frame
2459 * itself (or some other control data). The data is transferred
2460 * as-is and must be properly framed and checksummed as appropriate
2461 * by userspace. Frames are either sent whole or not at all as this
2462 * avoids pain user side.
2465 static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2466 const unsigned char *buf, size_t nr)
2468 int space = tty_write_room(tty);
2470 return tty->ops->write(tty, buf, nr);
2471 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2476 * gsmld_poll - poll method for N_GSM0710
2477 * @tty: terminal device
2478 * @file: file accessing it
2481 * Called when the line discipline is asked to poll() for data or
2482 * for special events. This code is not serialized with respect to
2483 * other events save open/close.
2485 * This code must be sure never to sleep through a hangup.
2486 * Called without the kernel lock held - fine
2489 static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2492 unsigned int mask = 0;
2493 struct gsm_mux *gsm = tty->disc_data;
2495 poll_wait(file, &tty->read_wait, wait);
2496 poll_wait(file, &tty->write_wait, wait);
2497 if (tty_hung_up_p(file))
2499 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2500 mask |= POLLOUT | POLLWRNORM;
2506 static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2507 struct gsm_config *c)
2510 int need_restart = 0;
2512 /* Stuff we don't support yet - UI or I frame transport, windowing */
2513 if ((c->adaption != 1 && c->adaption != 2) || c->k)
2515 /* Check the MRU/MTU range looks sane */
2516 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2520 if (c->encapsulation > 1) /* Basic, advanced, no I */
2522 if (c->initiator > 1)
2524 if (c->i == 0 || c->i > 2) /* UIH and UI only */
2527 * See what is needed for reconfiguration
2531 if (c->t1 != 0 && c->t1 != gsm->t1)
2533 if (c->t2 != 0 && c->t2 != gsm->t2)
2535 if (c->encapsulation != gsm->encoding)
2537 if (c->adaption != gsm->adaption)
2540 if (c->initiator != gsm->initiator)
2542 if (c->mru != gsm->mru)
2544 if (c->mtu != gsm->mtu)
2548 * Close down what is needed, restart and initiate the new
2552 if (need_close || need_restart) {
2553 gsm_dlci_begin_close(gsm->dlci[0]);
2554 /* This will timeout if the link is down due to N2 expiring */
2555 wait_event_interruptible(gsm->event,
2556 gsm->dlci[0]->state == DLCI_CLOSED);
2557 if (signal_pending(current))
2561 gsm_cleanup_mux(gsm);
2563 gsm->initiator = c->initiator;
2566 gsm->encoding = c->encapsulation;
2567 gsm->adaption = c->adaption;
2580 /* FIXME: We need to separate activation/deactivation from adding
2581 and removing from the mux array */
2583 gsm_activate_mux(gsm);
2584 if (gsm->initiator && need_close)
2585 gsm_dlci_begin_open(gsm->dlci[0]);
2589 static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2590 unsigned int cmd, unsigned long arg)
2592 struct gsm_config c;
2593 struct gsm_mux *gsm = tty->disc_data;
2596 case GSMIOC_GETCONF:
2597 memset(&c, 0, sizeof(c));
2598 c.adaption = gsm->adaption;
2599 c.encapsulation = gsm->encoding;
2600 c.initiator = gsm->initiator;
2603 c.t3 = 0; /* Not supported */
2605 if (gsm->ftype == UIH)
2609 pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
2613 if (copy_to_user((void *)arg, &c, sizeof(c)))
2616 case GSMIOC_SETCONF:
2617 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2619 return gsmld_config(tty, gsm, &c);
2621 return n_tty_ioctl_helper(tty, file, cmd, arg);
2630 static int gsm_mux_net_open(struct net_device *net)
2632 pr_debug("%s called\n", __func__);
2633 netif_start_queue(net);
2637 static int gsm_mux_net_close(struct net_device *net)
2639 netif_stop_queue(net);
2643 static struct net_device_stats *gsm_mux_net_get_stats(struct net_device *net)
2645 return &((struct gsm_mux_net *)netdev_priv(net))->stats;
2647 static void dlci_net_free(struct gsm_dlci *dlci)
2653 dlci->adaption = dlci->prev_adaption;
2654 dlci->data = dlci->prev_data;
2655 free_netdev(dlci->net);
2658 static void net_free(struct kref *ref)
2660 struct gsm_mux_net *mux_net;
2661 struct gsm_dlci *dlci;
2663 mux_net = container_of(ref, struct gsm_mux_net, ref);
2664 dlci = mux_net->dlci;
2667 unregister_netdev(dlci->net);
2668 dlci_net_free(dlci);
2672 static inline void muxnet_get(struct gsm_mux_net *mux_net)
2674 kref_get(&mux_net->ref);
2677 static inline void muxnet_put(struct gsm_mux_net *mux_net)
2679 kref_put(&mux_net->ref, net_free);
2682 static int gsm_mux_net_start_xmit(struct sk_buff *skb,
2683 struct net_device *net)
2685 struct gsm_mux_net *mux_net = netdev_priv(net);
2686 struct gsm_dlci *dlci = mux_net->dlci;
2687 muxnet_get(mux_net);
2689 skb_queue_head(&dlci->skb_list, skb);
2690 STATS(net).tx_packets++;
2691 STATS(net).tx_bytes += skb->len;
2692 gsm_dlci_data_kick(dlci);
2693 /* And tell the kernel when the last transmit started. */
2694 netif_trans_update(net);
2695 muxnet_put(mux_net);
2696 return NETDEV_TX_OK;
2699 /* called when a packet did not ack after watchdogtimeout */
2700 static void gsm_mux_net_tx_timeout(struct net_device *net)
2702 /* Tell syslog we are hosed. */
2703 dev_dbg(&net->dev, "Tx timed out.\n");
2705 /* Update statistics */
2706 STATS(net).tx_errors++;
2709 static void gsm_mux_rx_netchar(struct gsm_dlci *dlci,
2710 unsigned char *in_buf, int size)
2712 struct net_device *net = dlci->net;
2713 struct sk_buff *skb;
2714 struct gsm_mux_net *mux_net = netdev_priv(net);
2715 muxnet_get(mux_net);
2717 /* Allocate an sk_buff */
2718 skb = dev_alloc_skb(size + NET_IP_ALIGN);
2720 /* We got no receive buffer. */
2721 STATS(net).rx_dropped++;
2722 muxnet_put(mux_net);
2725 skb_reserve(skb, NET_IP_ALIGN);
2726 memcpy(skb_put(skb, size), in_buf, size);
2729 skb->protocol = htons(ETH_P_IP);
2731 /* Ship it off to the kernel */
2734 /* update out statistics */
2735 STATS(net).rx_packets++;
2736 STATS(net).rx_bytes += size;
2737 muxnet_put(mux_net);
2741 static int gsm_change_mtu(struct net_device *net, int new_mtu)
2743 struct gsm_mux_net *mux_net = netdev_priv(net);
2744 if ((new_mtu < 8) || (new_mtu > mux_net->dlci->gsm->mtu))
2750 static void gsm_mux_net_init(struct net_device *net)
2752 static const struct net_device_ops gsm_netdev_ops = {
2753 .ndo_open = gsm_mux_net_open,
2754 .ndo_stop = gsm_mux_net_close,
2755 .ndo_start_xmit = gsm_mux_net_start_xmit,
2756 .ndo_tx_timeout = gsm_mux_net_tx_timeout,
2757 .ndo_get_stats = gsm_mux_net_get_stats,
2758 .ndo_change_mtu = gsm_change_mtu,
2761 net->netdev_ops = &gsm_netdev_ops;
2763 /* fill in the other fields */
2764 net->watchdog_timeo = GSM_NET_TX_TIMEOUT;
2765 net->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
2766 net->type = ARPHRD_NONE;
2767 net->tx_queue_len = 10;
2771 /* caller holds the dlci mutex */
2772 static void gsm_destroy_network(struct gsm_dlci *dlci)
2774 struct gsm_mux_net *mux_net;
2776 pr_debug("destroy network interface");
2779 mux_net = netdev_priv(dlci->net);
2780 muxnet_put(mux_net);
2784 /* caller holds the dlci mutex */
2785 static int gsm_create_network(struct gsm_dlci *dlci, struct gsm_netconfig *nc)
2789 struct net_device *net;
2790 struct gsm_mux_net *mux_net;
2792 if (!capable(CAP_NET_ADMIN))
2795 /* Already in a non tty mode */
2796 if (dlci->adaption > 2)
2799 if (nc->protocol != htons(ETH_P_IP))
2800 return -EPROTONOSUPPORT;
2802 if (nc->adaption != 3 && nc->adaption != 4)
2803 return -EPROTONOSUPPORT;
2805 pr_debug("create network interface");
2808 if (nc->if_name[0] != '\0')
2809 netname = nc->if_name;
2810 net = alloc_netdev(sizeof(struct gsm_mux_net), netname,
2811 NET_NAME_UNKNOWN, gsm_mux_net_init);
2813 pr_err("alloc_netdev failed");
2816 net->mtu = dlci->gsm->mtu;
2817 mux_net = netdev_priv(net);
2818 mux_net->dlci = dlci;
2819 kref_init(&mux_net->ref);
2820 strncpy(nc->if_name, net->name, IFNAMSIZ); /* return net name */
2822 /* reconfigure dlci for network */
2823 dlci->prev_adaption = dlci->adaption;
2824 dlci->prev_data = dlci->data;
2825 dlci->adaption = nc->adaption;
2826 dlci->data = gsm_mux_rx_netchar;
2829 pr_debug("register netdev");
2830 retval = register_netdev(net);
2832 pr_err("network register fail %d\n", retval);
2833 dlci_net_free(dlci);
2836 return net->ifindex; /* return network index */
2839 /* Line discipline for real tty */
2840 static struct tty_ldisc_ops tty_ldisc_packet = {
2841 .owner = THIS_MODULE,
2842 .magic = TTY_LDISC_MAGIC,
2845 .close = gsmld_close,
2846 .flush_buffer = gsmld_flush_buffer,
2848 .write = gsmld_write,
2849 .ioctl = gsmld_ioctl,
2851 .receive_buf = gsmld_receive_buf,
2852 .write_wakeup = gsmld_write_wakeup
2861 static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2864 struct gsm_control *ctrl;
2870 modembits[0] = len << 1 | EA; /* Data bytes */
2871 modembits[1] = dlci->addr << 2 | 3; /* DLCI, EA, 1 */
2872 modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2874 modembits[3] = brk << 4 | 2 | EA; /* Valid, EA */
2875 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2878 return gsm_control_wait(dlci->gsm, ctrl);
2881 static int gsm_carrier_raised(struct tty_port *port)
2883 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2884 struct gsm_mux *gsm = dlci->gsm;
2886 /* Not yet open so no carrier info */
2887 if (dlci->state != DLCI_OPEN)
2893 * Basic mode with control channel in ADM mode may not respond
2894 * to CMD_MSC at all and modem_rx is empty.
2896 if (gsm->encoding == 0 && gsm->dlci[0]->mode == DLCI_MODE_ADM &&
2900 return dlci->modem_rx & TIOCM_CD;
2903 static void gsm_dtr_rts(struct tty_port *port, int onoff)
2905 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2906 unsigned int modem_tx = dlci->modem_tx;
2908 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2910 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2911 if (modem_tx != dlci->modem_tx) {
2912 dlci->modem_tx = modem_tx;
2913 gsmtty_modem_update(dlci, 0);
2917 static const struct tty_port_operations gsm_port_ops = {
2918 .carrier_raised = gsm_carrier_raised,
2919 .dtr_rts = gsm_dtr_rts,
2920 .destruct = gsm_dlci_free,
2923 static int gsmtty_install(struct tty_driver *driver, struct tty_struct *tty)
2925 struct gsm_mux *gsm;
2926 struct gsm_dlci *dlci;
2927 unsigned int line = tty->index;
2928 unsigned int mux = line >> 6;
2936 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2937 if (gsm_mux[mux] == NULL)
2939 if (line == 0 || line > 61) /* 62/63 reserved */
2944 /* If DLCI 0 is not yet fully open return an error.
2945 This is ok from a locking
2946 perspective as we don't have to worry about this
2948 mutex_lock(&gsm->mutex);
2949 if (gsm->dlci[0] && gsm->dlci[0]->state != DLCI_OPEN) {
2950 mutex_unlock(&gsm->mutex);
2953 dlci = gsm->dlci[line];
2956 dlci = gsm_dlci_alloc(gsm, line);
2959 mutex_unlock(&gsm->mutex);
2962 ret = tty_port_install(&dlci->port, driver, tty);
2966 mutex_unlock(&gsm->mutex);
2971 dlci_get(gsm->dlci[0]);
2973 tty->driver_data = dlci;
2974 mutex_unlock(&gsm->mutex);
2979 static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2981 struct gsm_dlci *dlci = tty->driver_data;
2982 struct tty_port *port = &dlci->port;
2985 tty_port_tty_set(port, tty);
2988 /* We could in theory open and close before we wait - eg if we get
2989 a DM straight back. This is ok as that will have caused a hangup */
2990 tty_port_set_initialized(port, 1);
2991 /* Start sending off SABM messages */
2992 gsm_dlci_begin_open(dlci);
2993 /* And wait for virtual carrier */
2994 return tty_port_block_til_ready(port, tty, filp);
2997 static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2999 struct gsm_dlci *dlci = tty->driver_data;
3000 struct gsm_mux *gsm;
3004 if (dlci->state == DLCI_CLOSED)
3006 mutex_lock(&dlci->mutex);
3007 gsm_destroy_network(dlci);
3008 mutex_unlock(&dlci->mutex);
3010 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
3012 gsm_dlci_begin_close(dlci);
3013 if (tty_port_initialized(&dlci->port) && C_HUPCL(tty))
3014 tty_port_lower_dtr_rts(&dlci->port);
3015 tty_port_close_end(&dlci->port, tty);
3016 tty_port_tty_set(&dlci->port, NULL);
3020 static void gsmtty_hangup(struct tty_struct *tty)
3022 struct gsm_dlci *dlci = tty->driver_data;
3023 if (dlci->state == DLCI_CLOSED)
3025 tty_port_hangup(&dlci->port);
3026 gsm_dlci_begin_close(dlci);
3029 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
3033 struct gsm_dlci *dlci = tty->driver_data;
3034 if (dlci->state == DLCI_CLOSED)
3036 /* Stuff the bytes into the fifo queue */
3037 sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
3038 /* Need to kick the channel */
3039 gsm_dlci_data_kick(dlci);
3043 static int gsmtty_write_room(struct tty_struct *tty)
3045 struct gsm_dlci *dlci = tty->driver_data;
3046 if (dlci->state == DLCI_CLOSED)
3048 return TX_SIZE - kfifo_len(dlci->fifo);
3051 static int gsmtty_chars_in_buffer(struct tty_struct *tty)
3053 struct gsm_dlci *dlci = tty->driver_data;
3054 if (dlci->state == DLCI_CLOSED)
3056 return kfifo_len(dlci->fifo);
3059 static void gsmtty_flush_buffer(struct tty_struct *tty)
3061 struct gsm_dlci *dlci = tty->driver_data;
3062 if (dlci->state == DLCI_CLOSED)
3064 /* Caution needed: If we implement reliable transport classes
3065 then the data being transmitted can't simply be junked once
3066 it has first hit the stack. Until then we can just blow it
3068 kfifo_reset(dlci->fifo);
3069 /* Need to unhook this DLCI from the transmit queue logic */
3072 static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
3074 /* The FIFO handles the queue so the kernel will do the right
3075 thing waiting on chars_in_buffer before calling us. No work
3079 static int gsmtty_tiocmget(struct tty_struct *tty)
3081 struct gsm_dlci *dlci = tty->driver_data;
3082 if (dlci->state == DLCI_CLOSED)
3084 return dlci->modem_rx;
3087 static int gsmtty_tiocmset(struct tty_struct *tty,
3088 unsigned int set, unsigned int clear)
3090 struct gsm_dlci *dlci = tty->driver_data;
3091 unsigned int modem_tx = dlci->modem_tx;
3093 if (dlci->state == DLCI_CLOSED)
3098 if (modem_tx != dlci->modem_tx) {
3099 dlci->modem_tx = modem_tx;
3100 return gsmtty_modem_update(dlci, 0);
3106 static int gsmtty_ioctl(struct tty_struct *tty,
3107 unsigned int cmd, unsigned long arg)
3109 struct gsm_dlci *dlci = tty->driver_data;
3110 struct gsm_netconfig nc;
3113 if (dlci->state == DLCI_CLOSED)
3116 case GSMIOC_ENABLE_NET:
3117 if (copy_from_user(&nc, (void __user *)arg, sizeof(nc)))
3119 nc.if_name[IFNAMSIZ-1] = '\0';
3120 /* return net interface index or error code */
3121 mutex_lock(&dlci->mutex);
3122 index = gsm_create_network(dlci, &nc);
3123 mutex_unlock(&dlci->mutex);
3124 if (copy_to_user((void __user *)arg, &nc, sizeof(nc)))
3127 case GSMIOC_DISABLE_NET:
3128 if (!capable(CAP_NET_ADMIN))
3130 mutex_lock(&dlci->mutex);
3131 gsm_destroy_network(dlci);
3132 mutex_unlock(&dlci->mutex);
3135 return -ENOIOCTLCMD;
3139 static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
3141 struct gsm_dlci *dlci = tty->driver_data;
3142 if (dlci->state == DLCI_CLOSED)
3144 /* For the moment its fixed. In actual fact the speed information
3145 for the virtual channel can be propogated in both directions by
3146 the RPN control message. This however rapidly gets nasty as we
3147 then have to remap modem signals each way according to whether
3148 our virtual cable is null modem etc .. */
3149 tty_termios_copy_hw(&tty->termios, old);
3152 static void gsmtty_throttle(struct tty_struct *tty)
3154 struct gsm_dlci *dlci = tty->driver_data;
3155 if (dlci->state == DLCI_CLOSED)
3158 dlci->modem_tx &= ~TIOCM_DTR;
3159 dlci->throttled = 1;
3160 /* Send an MSC with DTR cleared */
3161 gsmtty_modem_update(dlci, 0);
3164 static void gsmtty_unthrottle(struct tty_struct *tty)
3166 struct gsm_dlci *dlci = tty->driver_data;
3167 if (dlci->state == DLCI_CLOSED)
3170 dlci->modem_tx |= TIOCM_DTR;
3171 dlci->throttled = 0;
3172 /* Send an MSC with DTR set */
3173 gsmtty_modem_update(dlci, 0);
3176 static int gsmtty_break_ctl(struct tty_struct *tty, int state)
3178 struct gsm_dlci *dlci = tty->driver_data;
3179 int encode = 0; /* Off */
3180 if (dlci->state == DLCI_CLOSED)
3183 if (state == -1) /* "On indefinitely" - we can't encode this
3186 else if (state > 0) {
3187 encode = state / 200; /* mS to encoding */
3189 encode = 0x0F; /* Best effort */
3191 return gsmtty_modem_update(dlci, encode);
3194 static void gsmtty_cleanup(struct tty_struct *tty)
3196 struct gsm_dlci *dlci = tty->driver_data;
3197 struct gsm_mux *gsm = dlci->gsm;
3200 dlci_put(gsm->dlci[0]);
3204 /* Virtual ttys for the demux */
3205 static const struct tty_operations gsmtty_ops = {
3206 .install = gsmtty_install,
3207 .open = gsmtty_open,
3208 .close = gsmtty_close,
3209 .write = gsmtty_write,
3210 .write_room = gsmtty_write_room,
3211 .chars_in_buffer = gsmtty_chars_in_buffer,
3212 .flush_buffer = gsmtty_flush_buffer,
3213 .ioctl = gsmtty_ioctl,
3214 .throttle = gsmtty_throttle,
3215 .unthrottle = gsmtty_unthrottle,
3216 .set_termios = gsmtty_set_termios,
3217 .hangup = gsmtty_hangup,
3218 .wait_until_sent = gsmtty_wait_until_sent,
3219 .tiocmget = gsmtty_tiocmget,
3220 .tiocmset = gsmtty_tiocmset,
3221 .break_ctl = gsmtty_break_ctl,
3222 .cleanup = gsmtty_cleanup,
3227 static int __init gsm_init(void)
3229 /* Fill in our line protocol discipline, and register it */
3230 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
3232 pr_err("n_gsm: can't register line discipline (err = %d)\n",
3237 gsm_tty_driver = alloc_tty_driver(256);
3238 if (!gsm_tty_driver) {
3239 tty_unregister_ldisc(N_GSM0710);
3240 pr_err("gsm_init: tty allocation failed.\n");
3243 gsm_tty_driver->driver_name = "gsmtty";
3244 gsm_tty_driver->name = "gsmtty";
3245 gsm_tty_driver->major = 0; /* Dynamic */
3246 gsm_tty_driver->minor_start = 0;
3247 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
3248 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
3249 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
3250 | TTY_DRIVER_HARDWARE_BREAK;
3251 gsm_tty_driver->init_termios = tty_std_termios;
3253 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
3254 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
3256 spin_lock_init(&gsm_mux_lock);
3258 if (tty_register_driver(gsm_tty_driver)) {
3259 put_tty_driver(gsm_tty_driver);
3260 tty_unregister_ldisc(N_GSM0710);
3261 pr_err("gsm_init: tty registration failed.\n");
3264 pr_debug("gsm_init: loaded as %d,%d.\n",
3265 gsm_tty_driver->major, gsm_tty_driver->minor_start);
3269 static void __exit gsm_exit(void)
3271 int status = tty_unregister_ldisc(N_GSM0710);
3273 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
3275 tty_unregister_driver(gsm_tty_driver);
3276 put_tty_driver(gsm_tty_driver);
3279 module_init(gsm_init);
3280 module_exit(gsm_exit);
3283 MODULE_LICENSE("GPL");
3284 MODULE_ALIAS_LDISC(N_GSM0710);