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/signal.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
93 * Created when net interface is initialized.
97 struct gsm_dlci
*dlci
;
101 * Each block of data we have queued to go out is in the form of
102 * a gsm_msg which holds everything we need in a link layer independent
107 struct list_head list
;
108 u8 addr
; /* DLCI address + flags */
109 u8 ctrl
; /* Control byte + flags */
110 unsigned int len
; /* Length of data block (can be zero) */
111 unsigned char *data
; /* Points into buffer but not at the start */
112 unsigned char buffer
[0];
116 * Each active data link has a gsm_dlci structure associated which ties
117 * the link layer to an optional tty (if the tty side is open). To avoid
118 * complexity right now these are only ever freed up when the mux is
121 * At the moment we don't free DLCI objects until the mux is torn down
122 * this avoid object life time issues but might be worth review later.
129 #define DLCI_CLOSED 0
130 #define DLCI_OPENING 1 /* Sending SABM not seen UA */
131 #define DLCI_OPEN 2 /* SABM/UA complete */
132 #define DLCI_CLOSING 3 /* Sending DISC not seen UA/DM */
136 spinlock_t lock
; /* Protects the internal state */
137 struct timer_list t1
; /* Retransmit timer for SABM and UA */
139 /* Uplink tty if active */
140 struct tty_port port
; /* The tty bound to this DLCI if there is one */
141 struct kfifo
*fifo
; /* Queue fifo for the DLCI */
142 struct kfifo _fifo
; /* For new fifo API porting only */
143 int adaption
; /* Adaption layer in use */
145 u32 modem_rx
; /* Our incoming virtual modem lines */
146 u32 modem_tx
; /* Our outgoing modem lines */
147 int dead
; /* Refuse re-open */
149 int throttled
; /* Private copy of throttle state */
150 int constipated
; /* Throttle status for outgoing */
152 struct sk_buff
*skb
; /* Frame being sent */
153 struct sk_buff_head skb_list
; /* Queued frames */
154 /* Data handling callback */
155 void (*data
)(struct gsm_dlci
*dlci
, u8
*data
, int len
);
156 void (*prev_data
)(struct gsm_dlci
*dlci
, u8
*data
, int len
);
157 struct net_device
*net
; /* network interface, if created */
160 /* DLCI 0, 62/63 are special or reserved see gsmtty_open */
165 * DLCI 0 is used to pass control blocks out of band of the data
166 * flow (and with a higher link priority). One command can be outstanding
167 * at a time and we use this structure to manage them. They are created
168 * and destroyed by the user context, and updated by the receive paths
173 u8 cmd
; /* Command we are issuing */
174 u8
*data
; /* Data for the command in case we retransmit */
175 int len
; /* Length of block for retransmission */
176 int done
; /* Done flag */
177 int error
; /* Error if any */
181 * Each GSM mux we have is represented by this structure. If we are
182 * operating as an ldisc then we use this structure as our ldisc
183 * state. We need to sort out lifetimes and locking with respect
184 * to the gsm mux array. For now we don't free DLCI objects that
185 * have been instantiated until the mux itself is terminated.
187 * To consider further: tty open versus mux shutdown.
191 struct tty_struct
*tty
; /* The tty our ldisc is bound to */
197 /* Events on the GSM channel */
198 wait_queue_head_t event
;
200 /* Bits for GSM mode decoding */
207 #define GSM_ADDRESS 2
208 #define GSM_CONTROL 3
212 #define GSM_OVERRUN 7
217 unsigned int address
;
224 u8
*txframe
; /* TX framing buffer */
226 /* Methods for the receiver side */
227 void (*receive
)(struct gsm_mux
*gsm
, u8 ch
);
228 void (*error
)(struct gsm_mux
*gsm
, u8 ch
, u8 flag
);
229 /* And transmit side */
230 int (*output
)(struct gsm_mux
*mux
, u8
*data
, int len
);
235 int initiator
; /* Did we initiate connection */
236 int dead
; /* Has the mux been shut down */
237 struct gsm_dlci
*dlci
[NUM_DLCI
];
238 int constipated
; /* Asked by remote to shut up */
241 unsigned int tx_bytes
; /* TX data outstanding */
242 #define TX_THRESH_HI 8192
243 #define TX_THRESH_LO 2048
244 struct list_head tx_list
; /* Pending data packets */
246 /* Control messages */
247 struct timer_list t2_timer
; /* Retransmit timer for commands */
248 int cretries
; /* Command retry counter */
249 struct gsm_control
*pending_cmd
;/* Our current pending command */
250 spinlock_t control_lock
; /* Protects the pending command */
253 int adaption
; /* 1 or 2 supported */
254 u8 ftype
; /* UI or UIH */
255 int t1
, t2
; /* Timers in 1/100th of a sec */
256 int n2
; /* Retry count */
258 /* Statistics (not currently exposed) */
259 unsigned long bad_fcs
;
260 unsigned long malformed
;
261 unsigned long io_error
;
262 unsigned long bad_size
;
263 unsigned long unsupported
;
268 * Mux objects - needed so that we can translate a tty index into the
269 * relevant mux and DLCI.
272 #define MAX_MUX 4 /* 256 minors */
273 static struct gsm_mux
*gsm_mux
[MAX_MUX
]; /* GSM muxes */
274 static spinlock_t gsm_mux_lock
;
276 static struct tty_driver
*gsm_tty_driver
;
279 * This section of the driver logic implements the GSM encodings
280 * both the basic and the 'advanced'. Reliable transport is not
288 /* I is special: the rest are ..*/
299 /* Channel commands */
301 #define CMD_TEST 0x11
304 #define CMD_FCOFF 0x31
307 #define CMD_FCON 0x51
312 /* Virtual modem bits */
319 #define GSM0_SOF 0xF9
320 #define GSM1_SOF 0x7E
321 #define GSM1_ESCAPE 0x7D
322 #define GSM1_ESCAPE_BITS 0x20
326 static const struct tty_port_operations gsm_port_ops
;
329 * CRC table for GSM 0710
332 static const u8 gsm_fcs8
[256] = {
333 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
334 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
335 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
336 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
337 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
338 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
339 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
340 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
341 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
342 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
343 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
344 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
345 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
346 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
347 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
348 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
349 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
350 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
351 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
352 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
353 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
354 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
355 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
356 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
357 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
358 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
359 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
360 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
361 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
362 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
363 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
364 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
367 #define INIT_FCS 0xFF
368 #define GOOD_FCS 0xCF
371 * gsm_fcs_add - update FCS
375 * Update the FCS to include c. Uses the algorithm in the specification
379 static inline u8
gsm_fcs_add(u8 fcs
, u8 c
)
381 return gsm_fcs8
[fcs
^ c
];
385 * gsm_fcs_add_block - update FCS for a block
388 * @len: length of buffer
390 * Update the FCS to include c. Uses the algorithm in the specification
394 static inline u8
gsm_fcs_add_block(u8 fcs
, u8
*c
, int len
)
397 fcs
= gsm_fcs8
[fcs
^ *c
++];
402 * gsm_read_ea - read a byte into an EA
403 * @val: variable holding value
404 * c: byte going into the EA
406 * Processes one byte of an EA. Updates the passed variable
407 * and returns 1 if the EA is now completely read
410 static int gsm_read_ea(unsigned int *val
, u8 c
)
412 /* Add the next 7 bits into the value */
415 /* Was this the last byte of the EA 1 = yes*/
420 * gsm_encode_modem - encode modem data bits
421 * @dlci: DLCI to encode from
423 * Returns the correct GSM encoded modem status bits (6 bit field) for
424 * the current status of the DLCI and attached tty object
427 static u8
gsm_encode_modem(const struct gsm_dlci
*dlci
)
430 /* FC is true flow control not modem bits */
433 if (dlci
->modem_tx
& TIOCM_DTR
)
434 modembits
|= MDM_RTC
;
435 if (dlci
->modem_tx
& TIOCM_RTS
)
436 modembits
|= MDM_RTR
;
437 if (dlci
->modem_tx
& TIOCM_RI
)
439 if (dlci
->modem_tx
& TIOCM_CD
)
445 * gsm_print_packet - display a frame for debug
446 * @hdr: header to print before decode
447 * @addr: address EA from the frame
448 * @cr: C/R bit from the frame
449 * @control: control including PF bit
450 * @data: following data bytes
451 * @dlen: length of data
453 * Displays a packet in human readable format for debugging purposes. The
454 * style is based on amateur radio LAP-B dump display.
457 static void gsm_print_packet(const char *hdr
, int addr
, int cr
,
458 u8 control
, const u8
*data
, int dlen
)
463 pr_info("%s %d) %c: ", hdr
, addr
, "RC"[cr
]);
465 switch (control
& ~PF
) {
485 if (!(control
& 0x01)) {
486 pr_cont("I N(S)%d N(R)%d",
487 (control
& 0x0E) >> 1, (control
& 0xE0) >> 5);
488 } else switch (control
& 0x0F) {
490 pr_cont("RR(%d)", (control
& 0xE0) >> 5);
493 pr_cont("RNR(%d)", (control
& 0xE0) >> 5);
496 pr_cont("REJ(%d)", (control
& 0xE0) >> 5);
499 pr_cont("[%02X]", control
);
515 pr_cont("%02X ", *data
++);
524 * Link level transmission side
528 * gsm_stuff_packet - bytestuff a packet
531 * @len: length of input
533 * Expand a buffer by bytestuffing it. The worst case size change
534 * is doubling and the caller is responsible for handing out
535 * suitable sized buffers.
538 static int gsm_stuff_frame(const u8
*input
, u8
*output
, int len
)
542 if (*input
== GSM1_SOF
|| *input
== GSM1_ESCAPE
543 || *input
== XON
|| *input
== XOFF
) {
544 *output
++ = GSM1_ESCAPE
;
545 *output
++ = *input
++ ^ GSM1_ESCAPE_BITS
;
548 *output
++ = *input
++;
555 * gsm_send - send a control frame
557 * @addr: address for control frame
558 * @cr: command/response bit
559 * @control: control byte including PF bit
561 * Format up and transmit a control frame. These do not go via the
562 * queueing logic as they should be transmitted ahead of data when
565 * FIXME: Lock versus data TX path
568 static void gsm_send(struct gsm_mux
*gsm
, int addr
, int cr
, int control
)
574 switch (gsm
->encoding
) {
577 cbuf
[1] = (addr
<< 2) | (cr
<< 1) | EA
;
579 cbuf
[3] = EA
; /* Length of data = 0 */
580 cbuf
[4] = 0xFF - gsm_fcs_add_block(INIT_FCS
, cbuf
+ 1, 3);
586 /* Control frame + packing (but not frame stuffing) in mode 1 */
587 ibuf
[0] = (addr
<< 2) | (cr
<< 1) | EA
;
589 ibuf
[2] = 0xFF - gsm_fcs_add_block(INIT_FCS
, ibuf
, 2);
590 /* Stuffing may double the size worst case */
591 len
= gsm_stuff_frame(ibuf
, cbuf
+ 1, 3);
592 /* Now add the SOF markers */
594 cbuf
[len
+ 1] = GSM1_SOF
;
595 /* FIXME: we can omit the lead one in many cases */
602 gsm
->output(gsm
, cbuf
, len
);
603 gsm_print_packet("-->", addr
, cr
, control
, NULL
, 0);
607 * gsm_response - send a control response
609 * @addr: address for control frame
610 * @control: control byte including PF bit
612 * Format up and transmit a link level response frame.
615 static inline void gsm_response(struct gsm_mux
*gsm
, int addr
, int control
)
617 gsm_send(gsm
, addr
, 0, control
);
621 * gsm_command - send a control command
623 * @addr: address for control frame
624 * @control: control byte including PF bit
626 * Format up and transmit a link level command frame.
629 static inline void gsm_command(struct gsm_mux
*gsm
, int addr
, int control
)
631 gsm_send(gsm
, addr
, 1, control
);
634 /* Data transmission */
636 #define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
639 * gsm_data_alloc - allocate data frame
641 * @addr: DLCI address
642 * @len: length excluding header and FCS
643 * @ctrl: control byte
645 * Allocate a new data buffer for sending frames with data. Space is left
646 * at the front for header bytes but that is treated as an implementation
647 * detail and not for the high level code to use
650 static struct gsm_msg
*gsm_data_alloc(struct gsm_mux
*gsm
, u8 addr
, int len
,
653 struct gsm_msg
*m
= kmalloc(sizeof(struct gsm_msg
) + len
+ HDR_LEN
,
657 m
->data
= m
->buffer
+ HDR_LEN
- 1; /* Allow for FCS */
661 INIT_LIST_HEAD(&m
->list
);
666 * gsm_data_kick - poke the queue
669 * The tty device has called us to indicate that room has appeared in
670 * the transmit queue. Ram more data into the pipe if we have any
671 * If we have been flow-stopped by a CMD_FCOFF, then we can only
672 * send messages on DLCI0 until CMD_FCON
674 * FIXME: lock against link layer control transmissions
677 static void gsm_data_kick(struct gsm_mux
*gsm
)
679 struct gsm_msg
*msg
, *nmsg
;
683 list_for_each_entry_safe(msg
, nmsg
, &gsm
->tx_list
, list
) {
684 if (gsm
->constipated
&& msg
->addr
)
686 if (gsm
->encoding
!= 0) {
687 gsm
->txframe
[0] = GSM1_SOF
;
688 len
= gsm_stuff_frame(msg
->data
,
689 gsm
->txframe
+ 1, msg
->len
);
690 gsm
->txframe
[len
+ 1] = GSM1_SOF
;
693 gsm
->txframe
[0] = GSM0_SOF
;
694 memcpy(gsm
->txframe
+ 1 , msg
->data
, msg
->len
);
695 gsm
->txframe
[msg
->len
+ 1] = GSM0_SOF
;
700 print_hex_dump_bytes("gsm_data_kick: ",
704 if (gsm
->output(gsm
, gsm
->txframe
+ skip_sof
,
707 /* FIXME: Can eliminate one SOF in many more cases */
708 gsm
->tx_bytes
-= msg
->len
;
709 /* For a burst of frames skip the extra SOF within the
713 list_del(&msg
->list
);
719 * __gsm_data_queue - queue a UI or UIH frame
720 * @dlci: DLCI sending the data
721 * @msg: message queued
723 * Add data to the transmit queue and try and get stuff moving
724 * out of the mux tty if not already doing so. The Caller must hold
728 static void __gsm_data_queue(struct gsm_dlci
*dlci
, struct gsm_msg
*msg
)
730 struct gsm_mux
*gsm
= dlci
->gsm
;
732 u8
*fcs
= dp
+ msg
->len
;
734 /* Fill in the header */
735 if (gsm
->encoding
== 0) {
737 *--dp
= (msg
->len
<< 1) | EA
;
739 *--dp
= (msg
->len
>> 7); /* bits 7 - 15 */
740 *--dp
= (msg
->len
& 127) << 1; /* bits 0 - 6 */
746 *--dp
= (msg
->addr
<< 2) | 2 | EA
;
748 *--dp
= (msg
->addr
<< 2) | EA
;
749 *fcs
= gsm_fcs_add_block(INIT_FCS
, dp
, msg
->data
- dp
);
750 /* Ugly protocol layering violation */
751 if (msg
->ctrl
== UI
|| msg
->ctrl
== (UI
|PF
))
752 *fcs
= gsm_fcs_add_block(*fcs
, msg
->data
, msg
->len
);
755 gsm_print_packet("Q> ", msg
->addr
, gsm
->initiator
, msg
->ctrl
,
756 msg
->data
, msg
->len
);
758 /* Move the header back and adjust the length, also allow for the FCS
759 now tacked on the end */
760 msg
->len
+= (msg
->data
- dp
) + 1;
763 /* Add to the actual output queue */
764 list_add_tail(&msg
->list
, &gsm
->tx_list
);
765 gsm
->tx_bytes
+= msg
->len
;
770 * gsm_data_queue - queue a UI or UIH frame
771 * @dlci: DLCI sending the data
772 * @msg: message queued
774 * Add data to the transmit queue and try and get stuff moving
775 * out of the mux tty if not already doing so. Take the
776 * the gsm tx lock and dlci lock.
779 static void gsm_data_queue(struct gsm_dlci
*dlci
, struct gsm_msg
*msg
)
782 spin_lock_irqsave(&dlci
->gsm
->tx_lock
, flags
);
783 __gsm_data_queue(dlci
, msg
);
784 spin_unlock_irqrestore(&dlci
->gsm
->tx_lock
, flags
);
788 * gsm_dlci_data_output - try and push data out of a DLCI
790 * @dlci: the DLCI to pull data from
792 * Pull data from a DLCI and send it into the transmit queue if there
793 * is data. Keep to the MRU of the mux. This path handles the usual tty
794 * interface which is a byte stream with optional modem data.
796 * Caller must hold the tx_lock of the mux.
799 static int gsm_dlci_data_output(struct gsm_mux
*gsm
, struct gsm_dlci
*dlci
)
803 int len
, total_size
, size
;
804 int h
= dlci
->adaption
- 1;
808 len
= kfifo_len(dlci
->fifo
);
812 /* MTU/MRU count only the data bits */
818 msg
= gsm_data_alloc(gsm
, dlci
->addr
, size
, gsm
->ftype
);
819 /* FIXME: need a timer or something to kick this so it can't
820 get stuck with no work outstanding and no buffer free */
824 switch (dlci
->adaption
) {
825 case 1: /* Unstructured */
827 case 2: /* Unstructed with modem bits.
828 Always one byte as we never send inline break data */
829 *dp
++ = gsm_encode_modem(dlci
);
832 WARN_ON(kfifo_out_locked(dlci
->fifo
, dp
, len
, &dlci
->lock
) != len
);
833 __gsm_data_queue(dlci
, msg
);
836 /* Bytes of data we used up */
841 * gsm_dlci_data_output_framed - try and push data out of a DLCI
843 * @dlci: the DLCI to pull data from
845 * Pull data from a DLCI and send it into the transmit queue if there
846 * is data. Keep to the MRU of the mux. This path handles framed data
847 * queued as skbuffs to the DLCI.
849 * Caller must hold the tx_lock of the mux.
852 static int gsm_dlci_data_output_framed(struct gsm_mux
*gsm
,
853 struct gsm_dlci
*dlci
)
858 int last
= 0, first
= 0;
861 /* One byte per frame is used for B/F flags */
862 if (dlci
->adaption
== 4)
865 /* dlci->skb is locked by tx_lock */
866 if (dlci
->skb
== NULL
) {
867 dlci
->skb
= skb_dequeue_tail(&dlci
->skb_list
);
868 if (dlci
->skb
== NULL
)
872 len
= dlci
->skb
->len
+ overhead
;
874 /* MTU/MRU count only the data bits */
875 if (len
> gsm
->mtu
) {
876 if (dlci
->adaption
== 3) {
877 /* Over long frame, bin it */
878 dev_kfree_skb_any(dlci
->skb
);
886 size
= len
+ overhead
;
887 msg
= gsm_data_alloc(gsm
, dlci
->addr
, size
, gsm
->ftype
);
889 /* FIXME: need a timer or something to kick this so it can't
890 get stuck with no work outstanding and no buffer free */
892 skb_queue_tail(&dlci
->skb_list
, dlci
->skb
);
898 if (dlci
->adaption
== 4) { /* Interruptible framed (Packetised Data) */
899 /* Flag byte to carry the start/end info */
900 *dp
++ = last
<< 7 | first
<< 6 | 1; /* EA */
903 memcpy(dp
, dlci
->skb
->data
, len
);
904 skb_pull(dlci
->skb
, len
);
905 __gsm_data_queue(dlci
, msg
);
907 dev_kfree_skb_any(dlci
->skb
);
914 * gsm_dlci_data_sweep - look for data to send
917 * Sweep the GSM mux channels in priority order looking for ones with
918 * data to send. We could do with optimising this scan a bit. We aim
919 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
920 * TX_THRESH_LO we get called again
922 * FIXME: We should round robin between groups and in theory you can
923 * renegotiate DLCI priorities with optional stuff. Needs optimising.
926 static void gsm_dlci_data_sweep(struct gsm_mux
*gsm
)
929 /* Priority ordering: We should do priority with RR of the groups */
932 while (i
< NUM_DLCI
) {
933 struct gsm_dlci
*dlci
;
935 if (gsm
->tx_bytes
> TX_THRESH_HI
)
938 if (dlci
== NULL
|| dlci
->constipated
) {
942 if (dlci
->adaption
< 3 && !dlci
->net
)
943 len
= gsm_dlci_data_output(gsm
, dlci
);
945 len
= gsm_dlci_data_output_framed(gsm
, dlci
);
948 /* DLCI empty - try the next */
955 * gsm_dlci_data_kick - transmit if possible
956 * @dlci: DLCI to kick
958 * Transmit data from this DLCI if the queue is empty. We can't rely on
959 * a tty wakeup except when we filled the pipe so we need to fire off
960 * new data ourselves in other cases.
963 static void gsm_dlci_data_kick(struct gsm_dlci
*dlci
)
968 if (dlci
->constipated
)
971 spin_lock_irqsave(&dlci
->gsm
->tx_lock
, flags
);
972 /* If we have nothing running then we need to fire up */
973 sweep
= (dlci
->gsm
->tx_bytes
< TX_THRESH_LO
);
974 if (dlci
->gsm
->tx_bytes
== 0) {
976 gsm_dlci_data_output_framed(dlci
->gsm
, dlci
);
978 gsm_dlci_data_output(dlci
->gsm
, dlci
);
981 gsm_dlci_data_sweep(dlci
->gsm
);
982 spin_unlock_irqrestore(&dlci
->gsm
->tx_lock
, flags
);
986 * Control message processing
991 * gsm_control_reply - send a response frame to a control
993 * @cmd: the command to use
994 * @data: data to follow encoded info
995 * @dlen: length of data
997 * Encode up and queue a UI/UIH frame containing our response.
1000 static void gsm_control_reply(struct gsm_mux
*gsm
, int cmd
, u8
*data
,
1003 struct gsm_msg
*msg
;
1004 msg
= gsm_data_alloc(gsm
, 0, dlen
+ 2, gsm
->ftype
);
1007 msg
->data
[0] = (cmd
& 0xFE) << 1 | EA
; /* Clear C/R */
1008 msg
->data
[1] = (dlen
<< 1) | EA
;
1009 memcpy(msg
->data
+ 2, data
, dlen
);
1010 gsm_data_queue(gsm
->dlci
[0], msg
);
1014 * gsm_process_modem - process received modem status
1015 * @tty: virtual tty bound to the DLCI
1016 * @dlci: DLCI to affect
1017 * @modem: modem bits (full EA)
1019 * Used when a modem control message or line state inline in adaption
1020 * layer 2 is processed. Sort out the local modem state and throttles
1023 static void gsm_process_modem(struct tty_struct
*tty
, struct gsm_dlci
*dlci
,
1024 u32 modem
, int clen
)
1030 /* The modem status command can either contain one octet (v.24 signals)
1031 or two octets (v.24 signals + break signals). The length field will
1032 either be 2 or 3 respectively. This is specified in section
1033 5.4.6.3.7 of the 27.010 mux spec. */
1036 modem
= modem
& 0x7f;
1039 modem
= (modem
>> 7) & 0x7f;
1042 /* Flow control/ready to communicate */
1043 fc
= (modem
& MDM_FC
) || !(modem
& MDM_RTR
);
1044 if (fc
&& !dlci
->constipated
) {
1045 /* Need to throttle our output on this device */
1046 dlci
->constipated
= 1;
1047 } else if (!fc
&& dlci
->constipated
) {
1048 dlci
->constipated
= 0;
1049 gsm_dlci_data_kick(dlci
);
1052 /* Map modem bits */
1053 if (modem
& MDM_RTC
)
1054 mlines
|= TIOCM_DSR
| TIOCM_DTR
;
1055 if (modem
& MDM_RTR
)
1056 mlines
|= TIOCM_RTS
| TIOCM_CTS
;
1062 /* Carrier drop -> hangup */
1064 if ((mlines
& TIOCM_CD
) == 0 && (dlci
->modem_rx
& TIOCM_CD
))
1069 tty_insert_flip_char(&dlci
->port
, 0, TTY_BREAK
);
1070 dlci
->modem_rx
= mlines
;
1074 * gsm_control_modem - modem status received
1076 * @data: data following command
1077 * @clen: command length
1079 * We have received a modem status control message. This is used by
1080 * the GSM mux protocol to pass virtual modem line status and optionally
1081 * to indicate break signals. Unpack it, convert to Linux representation
1082 * and if need be stuff a break message down the tty.
1085 static void gsm_control_modem(struct gsm_mux
*gsm
, u8
*data
, int clen
)
1087 unsigned int addr
= 0;
1088 unsigned int modem
= 0;
1089 unsigned int brk
= 0;
1090 struct gsm_dlci
*dlci
;
1093 struct tty_struct
*tty
;
1095 while (gsm_read_ea(&addr
, *dp
++) == 0) {
1100 /* Must be at least one byte following the EA */
1106 /* Closed port, or invalid ? */
1107 if (addr
== 0 || addr
>= NUM_DLCI
|| gsm
->dlci
[addr
] == NULL
)
1109 dlci
= gsm
->dlci
[addr
];
1111 while (gsm_read_ea(&modem
, *dp
++) == 0) {
1118 while (gsm_read_ea(&brk
, *dp
++) == 0) {
1124 modem
|= (brk
& 0x7f);
1126 tty
= tty_port_tty_get(&dlci
->port
);
1127 gsm_process_modem(tty
, dlci
, modem
, clen
);
1132 gsm_control_reply(gsm
, CMD_MSC
, data
, clen
);
1136 * gsm_control_rls - remote line status
1139 * @clen: data length
1141 * The modem sends us a two byte message on the control channel whenever
1142 * it wishes to send us an error state from the virtual link. Stuff
1143 * this into the uplink tty if present
1146 static void gsm_control_rls(struct gsm_mux
*gsm
, u8
*data
, int clen
)
1148 struct tty_port
*port
;
1149 unsigned int addr
= 0;
1154 while (gsm_read_ea(&addr
, *dp
++) == 0) {
1159 /* Must be at least one byte following ea */
1164 /* Closed port, or invalid ? */
1165 if (addr
== 0 || addr
>= NUM_DLCI
|| gsm
->dlci
[addr
] == NULL
)
1169 if ((bits
& 1) == 0)
1172 port
= &gsm
->dlci
[addr
]->port
;
1175 tty_insert_flip_char(port
, 0, TTY_OVERRUN
);
1177 tty_insert_flip_char(port
, 0, TTY_PARITY
);
1179 tty_insert_flip_char(port
, 0, TTY_FRAME
);
1181 tty_flip_buffer_push(port
);
1183 gsm_control_reply(gsm
, CMD_RLS
, data
, clen
);
1186 static void gsm_dlci_begin_close(struct gsm_dlci
*dlci
);
1189 * gsm_control_message - DLCI 0 control processing
1191 * @command: the command EA
1192 * @data: data beyond the command/length EAs
1195 * Input processor for control messages from the other end of the link.
1196 * Processes the incoming request and queues a response frame or an
1197 * NSC response if not supported
1200 static void gsm_control_message(struct gsm_mux
*gsm
, unsigned int command
,
1204 unsigned long flags
;
1208 struct gsm_dlci
*dlci
= gsm
->dlci
[0];
1209 /* Modem wishes to close down */
1213 gsm_dlci_begin_close(dlci
);
1218 /* Modem wishes to test, reply with the data */
1219 gsm_control_reply(gsm
, CMD_TEST
, data
, clen
);
1222 /* Modem can accept data again */
1223 gsm
->constipated
= 0;
1224 gsm_control_reply(gsm
, CMD_FCON
, NULL
, 0);
1225 /* Kick the link in case it is idling */
1226 spin_lock_irqsave(&gsm
->tx_lock
, flags
);
1228 spin_unlock_irqrestore(&gsm
->tx_lock
, flags
);
1231 /* Modem wants us to STFU */
1232 gsm
->constipated
= 1;
1233 gsm_control_reply(gsm
, CMD_FCOFF
, NULL
, 0);
1236 /* Out of band modem line change indicator for a DLCI */
1237 gsm_control_modem(gsm
, data
, clen
);
1240 /* Out of band error reception for a DLCI */
1241 gsm_control_rls(gsm
, data
, clen
);
1244 /* Modem wishes to enter power saving state */
1245 gsm_control_reply(gsm
, CMD_PSC
, NULL
, 0);
1247 /* Optional unsupported commands */
1248 case CMD_PN
: /* Parameter negotiation */
1249 case CMD_RPN
: /* Remote port negotiation */
1250 case CMD_SNC
: /* Service negotiation command */
1252 /* Reply to bad commands with an NSC */
1254 gsm_control_reply(gsm
, CMD_NSC
, buf
, 1);
1260 * gsm_control_response - process a response to our control
1262 * @command: the command (response) EA
1263 * @data: data beyond the command/length EA
1266 * Process a response to an outstanding command. We only allow a single
1267 * control message in flight so this is fairly easy. All the clean up
1268 * is done by the caller, we just update the fields, flag it as done
1272 static void gsm_control_response(struct gsm_mux
*gsm
, unsigned int command
,
1275 struct gsm_control
*ctrl
;
1276 unsigned long flags
;
1278 spin_lock_irqsave(&gsm
->control_lock
, flags
);
1280 ctrl
= gsm
->pending_cmd
;
1281 /* Does the reply match our command */
1283 if (ctrl
!= NULL
&& (command
== ctrl
->cmd
|| command
== CMD_NSC
)) {
1284 /* Our command was replied to, kill the retry timer */
1285 del_timer(&gsm
->t2_timer
);
1286 gsm
->pending_cmd
= NULL
;
1287 /* Rejected by the other end */
1288 if (command
== CMD_NSC
)
1289 ctrl
->error
= -EOPNOTSUPP
;
1291 wake_up(&gsm
->event
);
1293 spin_unlock_irqrestore(&gsm
->control_lock
, flags
);
1297 * gsm_control_transmit - send control packet
1299 * @ctrl: frame to send
1301 * Send out a pending control command (called under control lock)
1304 static void gsm_control_transmit(struct gsm_mux
*gsm
, struct gsm_control
*ctrl
)
1306 struct gsm_msg
*msg
= gsm_data_alloc(gsm
, 0, ctrl
->len
+ 1, gsm
->ftype
);
1309 msg
->data
[0] = (ctrl
->cmd
<< 1) | 2 | EA
; /* command */
1310 memcpy(msg
->data
+ 1, ctrl
->data
, ctrl
->len
);
1311 gsm_data_queue(gsm
->dlci
[0], msg
);
1315 * gsm_control_retransmit - retransmit a control frame
1316 * @data: pointer to our gsm object
1318 * Called off the T2 timer expiry in order to retransmit control frames
1319 * that have been lost in the system somewhere. The control_lock protects
1320 * us from colliding with another sender or a receive completion event.
1321 * In that situation the timer may still occur in a small window but
1322 * gsm->pending_cmd will be NULL and we just let the timer expire.
1325 static void gsm_control_retransmit(unsigned long data
)
1327 struct gsm_mux
*gsm
= (struct gsm_mux
*)data
;
1328 struct gsm_control
*ctrl
;
1329 unsigned long flags
;
1330 spin_lock_irqsave(&gsm
->control_lock
, flags
);
1331 ctrl
= gsm
->pending_cmd
;
1334 if (gsm
->cretries
== 0) {
1335 gsm
->pending_cmd
= NULL
;
1336 ctrl
->error
= -ETIMEDOUT
;
1338 spin_unlock_irqrestore(&gsm
->control_lock
, flags
);
1339 wake_up(&gsm
->event
);
1342 gsm_control_transmit(gsm
, ctrl
);
1343 mod_timer(&gsm
->t2_timer
, jiffies
+ gsm
->t2
* HZ
/ 100);
1345 spin_unlock_irqrestore(&gsm
->control_lock
, flags
);
1349 * gsm_control_send - send a control frame on DLCI 0
1350 * @gsm: the GSM channel
1351 * @command: command to send including CR bit
1352 * @data: bytes of data (must be kmalloced)
1353 * @len: length of the block to send
1355 * Queue and dispatch a control command. Only one command can be
1356 * active at a time. In theory more can be outstanding but the matching
1357 * gets really complicated so for now stick to one outstanding.
1360 static struct gsm_control
*gsm_control_send(struct gsm_mux
*gsm
,
1361 unsigned int command
, u8
*data
, int clen
)
1363 struct gsm_control
*ctrl
= kzalloc(sizeof(struct gsm_control
),
1365 unsigned long flags
;
1369 wait_event(gsm
->event
, gsm
->pending_cmd
== NULL
);
1370 spin_lock_irqsave(&gsm
->control_lock
, flags
);
1371 if (gsm
->pending_cmd
!= NULL
) {
1372 spin_unlock_irqrestore(&gsm
->control_lock
, flags
);
1375 ctrl
->cmd
= command
;
1378 gsm
->pending_cmd
= ctrl
;
1379 gsm
->cretries
= gsm
->n2
;
1380 mod_timer(&gsm
->t2_timer
, jiffies
+ gsm
->t2
* HZ
/ 100);
1381 gsm_control_transmit(gsm
, ctrl
);
1382 spin_unlock_irqrestore(&gsm
->control_lock
, flags
);
1387 * gsm_control_wait - wait for a control to finish
1389 * @control: control we are waiting on
1391 * Waits for the control to complete or time out. Frees any used
1392 * resources and returns 0 for success, or an error if the remote
1393 * rejected or ignored the request.
1396 static int gsm_control_wait(struct gsm_mux
*gsm
, struct gsm_control
*control
)
1399 wait_event(gsm
->event
, control
->done
== 1);
1400 err
= control
->error
;
1407 * DLCI level handling: Needs krefs
1411 * State transitions and timers
1415 * gsm_dlci_close - a DLCI has closed
1416 * @dlci: DLCI that closed
1418 * Perform processing when moving a DLCI into closed state. If there
1419 * is an attached tty this is hung up
1422 static void gsm_dlci_close(struct gsm_dlci
*dlci
)
1424 del_timer(&dlci
->t1
);
1426 pr_debug("DLCI %d goes closed.\n", dlci
->addr
);
1427 dlci
->state
= DLCI_CLOSED
;
1428 if (dlci
->addr
!= 0) {
1429 tty_port_tty_hangup(&dlci
->port
, false);
1430 kfifo_reset(dlci
->fifo
);
1432 dlci
->gsm
->dead
= 1;
1433 wake_up(&dlci
->gsm
->event
);
1434 /* A DLCI 0 close is a MUX termination so we need to kick that
1435 back to userspace somehow */
1439 * gsm_dlci_open - a DLCI has opened
1440 * @dlci: DLCI that opened
1442 * Perform processing when moving a DLCI into open state.
1445 static void gsm_dlci_open(struct gsm_dlci
*dlci
)
1447 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1449 del_timer(&dlci
->t1
);
1450 /* This will let a tty open continue */
1451 dlci
->state
= DLCI_OPEN
;
1453 pr_debug("DLCI %d goes open.\n", dlci
->addr
);
1454 wake_up(&dlci
->gsm
->event
);
1458 * gsm_dlci_t1 - T1 timer expiry
1459 * @dlci: DLCI that opened
1461 * The T1 timer handles retransmits of control frames (essentially of
1462 * SABM and DISC). We resend the command until the retry count runs out
1463 * in which case an opening port goes back to closed and a closing port
1464 * is simply put into closed state (any further frames from the other
1465 * end will get a DM response)
1468 static void gsm_dlci_t1(unsigned long data
)
1470 struct gsm_dlci
*dlci
= (struct gsm_dlci
*)data
;
1471 struct gsm_mux
*gsm
= dlci
->gsm
;
1473 switch (dlci
->state
) {
1476 if (dlci
->retries
) {
1477 gsm_command(dlci
->gsm
, dlci
->addr
, SABM
|PF
);
1478 mod_timer(&dlci
->t1
, jiffies
+ gsm
->t1
* HZ
/ 100);
1480 gsm_dlci_close(dlci
);
1484 if (dlci
->retries
) {
1485 gsm_command(dlci
->gsm
, dlci
->addr
, DISC
|PF
);
1486 mod_timer(&dlci
->t1
, jiffies
+ gsm
->t1
* HZ
/ 100);
1488 gsm_dlci_close(dlci
);
1494 * gsm_dlci_begin_open - start channel open procedure
1495 * @dlci: DLCI to open
1497 * Commence opening a DLCI from the Linux side. We issue SABM messages
1498 * to the modem which should then reply with a UA, at which point we
1499 * will move into open state. Opening is done asynchronously with retry
1500 * running off timers and the responses.
1503 static void gsm_dlci_begin_open(struct gsm_dlci
*dlci
)
1505 struct gsm_mux
*gsm
= dlci
->gsm
;
1506 if (dlci
->state
== DLCI_OPEN
|| dlci
->state
== DLCI_OPENING
)
1508 dlci
->retries
= gsm
->n2
;
1509 dlci
->state
= DLCI_OPENING
;
1510 gsm_command(dlci
->gsm
, dlci
->addr
, SABM
|PF
);
1511 mod_timer(&dlci
->t1
, jiffies
+ gsm
->t1
* HZ
/ 100);
1515 * gsm_dlci_begin_close - start channel open procedure
1516 * @dlci: DLCI to open
1518 * Commence closing a DLCI from the Linux side. We issue DISC messages
1519 * to the modem which should then reply with a UA, at which point we
1520 * will move into closed state. Closing is done asynchronously with retry
1521 * off timers. We may also receive a DM reply from the other end which
1522 * indicates the channel was already closed.
1525 static void gsm_dlci_begin_close(struct gsm_dlci
*dlci
)
1527 struct gsm_mux
*gsm
= dlci
->gsm
;
1528 if (dlci
->state
== DLCI_CLOSED
|| dlci
->state
== DLCI_CLOSING
)
1530 dlci
->retries
= gsm
->n2
;
1531 dlci
->state
= DLCI_CLOSING
;
1532 gsm_command(dlci
->gsm
, dlci
->addr
, DISC
|PF
);
1533 mod_timer(&dlci
->t1
, jiffies
+ gsm
->t1
* HZ
/ 100);
1537 * gsm_dlci_data - data arrived
1539 * @data: block of bytes received
1540 * @len: length of received block
1542 * A UI or UIH frame has arrived which contains data for a channel
1543 * other than the control channel. If the relevant virtual tty is
1544 * open we shovel the bits down it, if not we drop them.
1547 static void gsm_dlci_data(struct gsm_dlci
*dlci
, u8
*data
, int clen
)
1550 struct tty_port
*port
= &dlci
->port
;
1551 struct tty_struct
*tty
;
1552 unsigned int modem
= 0;
1556 pr_debug("%d bytes for tty\n", len
);
1557 switch (dlci
->adaption
) {
1558 /* Unsupported types */
1559 /* Packetised interruptible data */
1562 /* Packetised uininterruptible voice/data */
1565 /* Asynchronous serial with line state in each frame */
1567 while (gsm_read_ea(&modem
, *data
++) == 0) {
1572 tty
= tty_port_tty_get(port
);
1574 gsm_process_modem(tty
, dlci
, modem
, clen
);
1577 /* Line state will go via DLCI 0 controls only */
1580 tty_insert_flip_string(port
, data
, len
);
1581 tty_flip_buffer_push(port
);
1586 * gsm_dlci_control - data arrived on control channel
1588 * @data: block of bytes received
1589 * @len: length of received block
1591 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1592 * control channel. This should contain a command EA followed by
1593 * control data bytes. The command EA contains a command/response bit
1594 * and we divide up the work accordingly.
1597 static void gsm_dlci_command(struct gsm_dlci
*dlci
, u8
*data
, int len
)
1599 /* See what command is involved */
1600 unsigned int command
= 0;
1602 if (gsm_read_ea(&command
, *data
++) == 1) {
1605 /* FIXME: this is properly an EA */
1607 /* Malformed command ? */
1611 gsm_control_message(dlci
->gsm
, command
,
1614 gsm_control_response(dlci
->gsm
, command
,
1622 * Allocate/Free DLCI channels
1626 * gsm_dlci_alloc - allocate a DLCI
1628 * @addr: address of the DLCI
1630 * Allocate and install a new DLCI object into the GSM mux.
1632 * FIXME: review locking races
1635 static struct gsm_dlci
*gsm_dlci_alloc(struct gsm_mux
*gsm
, int addr
)
1637 struct gsm_dlci
*dlci
= kzalloc(sizeof(struct gsm_dlci
), GFP_ATOMIC
);
1640 spin_lock_init(&dlci
->lock
);
1641 mutex_init(&dlci
->mutex
);
1642 dlci
->fifo
= &dlci
->_fifo
;
1643 if (kfifo_alloc(&dlci
->_fifo
, 4096, GFP_KERNEL
) < 0) {
1648 skb_queue_head_init(&dlci
->skb_list
);
1649 init_timer(&dlci
->t1
);
1650 dlci
->t1
.function
= gsm_dlci_t1
;
1651 dlci
->t1
.data
= (unsigned long)dlci
;
1652 tty_port_init(&dlci
->port
);
1653 dlci
->port
.ops
= &gsm_port_ops
;
1656 dlci
->adaption
= gsm
->adaption
;
1657 dlci
->state
= DLCI_CLOSED
;
1659 dlci
->data
= gsm_dlci_data
;
1661 dlci
->data
= gsm_dlci_command
;
1662 gsm
->dlci
[addr
] = dlci
;
1667 * gsm_dlci_free - free DLCI
1668 * @dlci: DLCI to free
1674 static void gsm_dlci_free(struct tty_port
*port
)
1676 struct gsm_dlci
*dlci
= container_of(port
, struct gsm_dlci
, port
);
1678 del_timer_sync(&dlci
->t1
);
1679 dlci
->gsm
->dlci
[dlci
->addr
] = NULL
;
1680 kfifo_free(dlci
->fifo
);
1681 while ((dlci
->skb
= skb_dequeue(&dlci
->skb_list
)))
1682 dev_kfree_skb(dlci
->skb
);
1686 static inline void dlci_get(struct gsm_dlci
*dlci
)
1688 tty_port_get(&dlci
->port
);
1691 static inline void dlci_put(struct gsm_dlci
*dlci
)
1693 tty_port_put(&dlci
->port
);
1696 static void gsm_destroy_network(struct gsm_dlci
*dlci
);
1699 * gsm_dlci_release - release DLCI
1700 * @dlci: DLCI to destroy
1702 * Release a DLCI. Actual free is deferred until either
1703 * mux is closed or tty is closed - whichever is last.
1707 static void gsm_dlci_release(struct gsm_dlci
*dlci
)
1709 struct tty_struct
*tty
= tty_port_tty_get(&dlci
->port
);
1711 mutex_lock(&dlci
->mutex
);
1712 gsm_destroy_network(dlci
);
1713 mutex_unlock(&dlci
->mutex
);
1717 tty_port_tty_set(&dlci
->port
, NULL
);
1720 dlci
->state
= DLCI_CLOSED
;
1725 * LAPBish link layer logic
1729 * gsm_queue - a GSM frame is ready to process
1730 * @gsm: pointer to our gsm mux
1732 * At this point in time a frame has arrived and been demangled from
1733 * the line encoding. All the differences between the encodings have
1734 * been handled below us and the frame is unpacked into the structures.
1735 * The fcs holds the header FCS but any data FCS must be added here.
1738 static void gsm_queue(struct gsm_mux
*gsm
)
1740 struct gsm_dlci
*dlci
;
1743 /* We have to sneak a look at the packet body to do the FCS.
1744 A somewhat layering violation in the spec */
1746 if ((gsm
->control
& ~PF
) == UI
)
1747 gsm
->fcs
= gsm_fcs_add_block(gsm
->fcs
, gsm
->buf
, gsm
->len
);
1748 if (gsm
->encoding
== 0) {
1749 /* WARNING: gsm->received_fcs is used for
1750 gsm->encoding = 0 only.
1751 In this case it contain the last piece of data
1752 required to generate final CRC */
1753 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, gsm
->received_fcs
);
1755 if (gsm
->fcs
!= GOOD_FCS
) {
1758 pr_debug("BAD FCS %02x\n", gsm
->fcs
);
1761 address
= gsm
->address
>> 1;
1762 if (address
>= NUM_DLCI
)
1765 cr
= gsm
->address
& 1; /* C/R bit */
1767 gsm_print_packet("<--", address
, cr
, gsm
->control
, gsm
->buf
, gsm
->len
);
1769 cr
^= 1 - gsm
->initiator
; /* Flip so 1 always means command */
1770 dlci
= gsm
->dlci
[address
];
1772 switch (gsm
->control
) {
1777 dlci
= gsm_dlci_alloc(gsm
, address
);
1781 gsm_response(gsm
, address
, DM
);
1783 gsm_response(gsm
, address
, UA
);
1784 gsm_dlci_open(dlci
);
1790 if (dlci
== NULL
|| dlci
->state
== DLCI_CLOSED
) {
1791 gsm_response(gsm
, address
, DM
);
1794 /* Real close complete */
1795 gsm_response(gsm
, address
, UA
);
1796 gsm_dlci_close(dlci
);
1800 if (cr
== 0 || dlci
== NULL
)
1802 switch (dlci
->state
) {
1804 gsm_dlci_close(dlci
);
1807 gsm_dlci_open(dlci
);
1811 case DM
: /* DM can be valid unsolicited */
1817 gsm_dlci_close(dlci
);
1827 if (dlci
== NULL
|| dlci
->state
!= DLCI_OPEN
) {
1828 gsm_command(gsm
, address
, DM
|PF
);
1831 dlci
->data(dlci
, gsm
->buf
, gsm
->len
);
1844 * gsm0_receive - perform processing for non-transparency
1845 * @gsm: gsm data for this ldisc instance
1848 * Receive bytes in gsm mode 0
1851 static void gsm0_receive(struct gsm_mux
*gsm
, unsigned char c
)
1855 switch (gsm
->state
) {
1856 case GSM_SEARCH
: /* SOF marker */
1857 if (c
== GSM0_SOF
) {
1858 gsm
->state
= GSM_ADDRESS
;
1861 gsm
->fcs
= INIT_FCS
;
1864 case GSM_ADDRESS
: /* Address EA */
1865 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, c
);
1866 if (gsm_read_ea(&gsm
->address
, c
))
1867 gsm
->state
= GSM_CONTROL
;
1869 case GSM_CONTROL
: /* Control Byte */
1870 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, c
);
1872 gsm
->state
= GSM_LEN0
;
1874 case GSM_LEN0
: /* Length EA */
1875 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, c
);
1876 if (gsm_read_ea(&gsm
->len
, c
)) {
1877 if (gsm
->len
> gsm
->mru
) {
1879 gsm
->state
= GSM_SEARCH
;
1884 gsm
->state
= GSM_FCS
;
1886 gsm
->state
= GSM_DATA
;
1889 gsm
->state
= GSM_LEN1
;
1892 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, c
);
1894 gsm
->len
|= len
<< 7;
1895 if (gsm
->len
> gsm
->mru
) {
1897 gsm
->state
= GSM_SEARCH
;
1902 gsm
->state
= GSM_FCS
;
1904 gsm
->state
= GSM_DATA
;
1906 case GSM_DATA
: /* Data */
1907 gsm
->buf
[gsm
->count
++] = c
;
1908 if (gsm
->count
== gsm
->len
)
1909 gsm
->state
= GSM_FCS
;
1911 case GSM_FCS
: /* FCS follows the packet */
1912 gsm
->received_fcs
= c
;
1914 gsm
->state
= GSM_SSOF
;
1917 if (c
== GSM0_SOF
) {
1918 gsm
->state
= GSM_SEARCH
;
1926 * gsm1_receive - perform processing for non-transparency
1927 * @gsm: gsm data for this ldisc instance
1930 * Receive bytes in mode 1 (Advanced option)
1933 static void gsm1_receive(struct gsm_mux
*gsm
, unsigned char c
)
1935 if (c
== GSM1_SOF
) {
1936 /* EOF is only valid in frame if we have got to the data state
1937 and received at least one byte (the FCS) */
1938 if (gsm
->state
== GSM_DATA
&& gsm
->count
) {
1939 /* Extract the FCS */
1941 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, gsm
->buf
[gsm
->count
]);
1942 gsm
->len
= gsm
->count
;
1944 gsm
->state
= GSM_START
;
1947 /* Any partial frame was a runt so go back to start */
1948 if (gsm
->state
!= GSM_START
) {
1950 gsm
->state
= GSM_START
;
1952 /* A SOF in GSM_START means we are still reading idling or
1957 if (c
== GSM1_ESCAPE
) {
1962 /* Only an unescaped SOF gets us out of GSM search */
1963 if (gsm
->state
== GSM_SEARCH
)
1967 c
^= GSM1_ESCAPE_BITS
;
1970 switch (gsm
->state
) {
1971 case GSM_START
: /* First byte after SOF */
1973 gsm
->state
= GSM_ADDRESS
;
1974 gsm
->fcs
= INIT_FCS
;
1976 case GSM_ADDRESS
: /* Address continuation */
1977 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, c
);
1978 if (gsm_read_ea(&gsm
->address
, c
))
1979 gsm
->state
= GSM_CONTROL
;
1981 case GSM_CONTROL
: /* Control Byte */
1982 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, c
);
1985 gsm
->state
= GSM_DATA
;
1987 case GSM_DATA
: /* Data */
1988 if (gsm
->count
> gsm
->mru
) { /* Allow one for the FCS */
1989 gsm
->state
= GSM_OVERRUN
;
1992 gsm
->buf
[gsm
->count
++] = c
;
1994 case GSM_OVERRUN
: /* Over-long - eg a dropped SOF */
2000 * gsm_error - handle tty error
2002 * @data: byte received (may be invalid)
2003 * @flag: error received
2005 * Handle an error in the receipt of data for a frame. Currently we just
2006 * go back to hunting for a SOF.
2008 * FIXME: better diagnostics ?
2011 static void gsm_error(struct gsm_mux
*gsm
,
2012 unsigned char data
, unsigned char flag
)
2014 gsm
->state
= GSM_SEARCH
;
2019 * gsm_cleanup_mux - generic GSM protocol cleanup
2022 * Clean up the bits of the mux which are the same for all framing
2023 * protocols. Remove the mux from the mux table, stop all the timers
2024 * and then shut down each device hanging up the channels as we go.
2027 static void gsm_cleanup_mux(struct gsm_mux
*gsm
)
2030 struct gsm_dlci
*dlci
= gsm
->dlci
[0];
2031 struct gsm_msg
*txq
, *ntxq
;
2032 struct gsm_control
*gc
;
2036 spin_lock(&gsm_mux_lock
);
2037 for (i
= 0; i
< MAX_MUX
; i
++) {
2038 if (gsm_mux
[i
] == gsm
) {
2043 spin_unlock(&gsm_mux_lock
);
2044 /* open failed before registering => nothing to do */
2048 /* In theory disconnecting DLCI 0 is sufficient but for some
2049 modems this is apparently not the case. */
2051 gc
= gsm_control_send(gsm
, CMD_CLD
, NULL
, 0);
2053 gsm_control_wait(gsm
, gc
);
2055 del_timer_sync(&gsm
->t2_timer
);
2056 /* Now we are sure T2 has stopped */
2059 gsm_dlci_begin_close(dlci
);
2060 wait_event_interruptible(gsm
->event
,
2061 dlci
->state
== DLCI_CLOSED
);
2063 /* Free up any link layer users */
2064 mutex_lock(&gsm
->mutex
);
2065 for (i
= 0; i
< NUM_DLCI
; i
++)
2067 gsm_dlci_release(gsm
->dlci
[i
]);
2068 mutex_unlock(&gsm
->mutex
);
2069 /* Now wipe the queues */
2070 list_for_each_entry_safe(txq
, ntxq
, &gsm
->tx_list
, list
)
2072 INIT_LIST_HEAD(&gsm
->tx_list
);
2076 * gsm_activate_mux - generic GSM setup
2079 * Set up the bits of the mux which are the same for all framing
2080 * protocols. Add the mux to the mux table so it can be opened and
2081 * finally kick off connecting to DLCI 0 on the modem.
2084 static int gsm_activate_mux(struct gsm_mux
*gsm
)
2086 struct gsm_dlci
*dlci
;
2089 setup_timer(&gsm
->t2_timer
, gsm_control_retransmit
, (unsigned long)gsm
);
2090 init_waitqueue_head(&gsm
->event
);
2091 spin_lock_init(&gsm
->control_lock
);
2092 spin_lock_init(&gsm
->tx_lock
);
2094 if (gsm
->encoding
== 0)
2095 gsm
->receive
= gsm0_receive
;
2097 gsm
->receive
= gsm1_receive
;
2098 gsm
->error
= gsm_error
;
2100 spin_lock(&gsm_mux_lock
);
2101 for (i
= 0; i
< MAX_MUX
; i
++) {
2102 if (gsm_mux
[i
] == NULL
) {
2108 spin_unlock(&gsm_mux_lock
);
2112 dlci
= gsm_dlci_alloc(gsm
, 0);
2115 gsm
->dead
= 0; /* Tty opens are now permissible */
2120 * gsm_free_mux - free up a mux
2123 * Dispose of allocated resources for a dead mux
2125 static void gsm_free_mux(struct gsm_mux
*gsm
)
2127 kfree(gsm
->txframe
);
2133 * gsm_free_muxr - free up a mux
2136 * Dispose of allocated resources for a dead mux
2138 static void gsm_free_muxr(struct kref
*ref
)
2140 struct gsm_mux
*gsm
= container_of(ref
, struct gsm_mux
, ref
);
2144 static inline void mux_get(struct gsm_mux
*gsm
)
2146 kref_get(&gsm
->ref
);
2149 static inline void mux_put(struct gsm_mux
*gsm
)
2151 kref_put(&gsm
->ref
, gsm_free_muxr
);
2155 * gsm_alloc_mux - allocate a mux
2157 * Creates a new mux ready for activation.
2160 static struct gsm_mux
*gsm_alloc_mux(void)
2162 struct gsm_mux
*gsm
= kzalloc(sizeof(struct gsm_mux
), GFP_KERNEL
);
2165 gsm
->buf
= kmalloc(MAX_MRU
+ 1, GFP_KERNEL
);
2166 if (gsm
->buf
== NULL
) {
2170 gsm
->txframe
= kmalloc(2 * MAX_MRU
+ 2, GFP_KERNEL
);
2171 if (gsm
->txframe
== NULL
) {
2176 spin_lock_init(&gsm
->lock
);
2177 mutex_init(&gsm
->mutex
);
2178 kref_init(&gsm
->ref
);
2179 INIT_LIST_HEAD(&gsm
->tx_list
);
2187 gsm
->mru
= 64; /* Default to encoding 1 so these should be 64 */
2189 gsm
->dead
= 1; /* Avoid early tty opens */
2195 * gsmld_output - write to link
2197 * @data: bytes to output
2200 * Write a block of data from the GSM mux to the data channel. This
2201 * will eventually be serialized from above but at the moment isn't.
2204 static int gsmld_output(struct gsm_mux
*gsm
, u8
*data
, int len
)
2206 if (tty_write_room(gsm
->tty
) < len
) {
2207 set_bit(TTY_DO_WRITE_WAKEUP
, &gsm
->tty
->flags
);
2211 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET
,
2213 gsm
->tty
->ops
->write(gsm
->tty
, data
, len
);
2218 * gsmld_attach_gsm - mode set up
2219 * @tty: our tty structure
2222 * Set up the MUX for basic mode and commence connecting to the
2223 * modem. Currently called from the line discipline set up but
2224 * will need moving to an ioctl path.
2227 static int gsmld_attach_gsm(struct tty_struct
*tty
, struct gsm_mux
*gsm
)
2231 gsm
->tty
= tty_kref_get(tty
);
2232 gsm
->output
= gsmld_output
;
2233 ret
= gsm_activate_mux(gsm
);
2235 tty_kref_put(gsm
->tty
);
2237 /* Don't register device 0 - this is the control channel and not
2238 a usable tty interface */
2239 base
= gsm
->num
<< 6; /* Base for this MUX */
2240 for (i
= 1; i
< NUM_DLCI
; i
++)
2241 tty_register_device(gsm_tty_driver
, base
+ i
, NULL
);
2248 * gsmld_detach_gsm - stop doing 0710 mux
2249 * @tty: tty attached to the mux
2252 * Shutdown and then clean up the resources used by the line discipline
2255 static void gsmld_detach_gsm(struct tty_struct
*tty
, struct gsm_mux
*gsm
)
2258 int base
= gsm
->num
<< 6; /* Base for this MUX */
2260 WARN_ON(tty
!= gsm
->tty
);
2261 for (i
= 1; i
< NUM_DLCI
; i
++)
2262 tty_unregister_device(gsm_tty_driver
, base
+ i
);
2263 gsm_cleanup_mux(gsm
);
2264 tty_kref_put(gsm
->tty
);
2268 static void gsmld_receive_buf(struct tty_struct
*tty
, const unsigned char *cp
,
2269 char *fp
, int count
)
2271 struct gsm_mux
*gsm
= tty
->disc_data
;
2272 const unsigned char *dp
;
2275 char flags
= TTY_NORMAL
;
2278 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET
,
2281 for (i
= count
, dp
= cp
, f
= fp
; i
; i
--, dp
++) {
2286 gsm
->receive(gsm
, *dp
);
2292 gsm
->error(gsm
, *dp
, flags
);
2295 WARN_ONCE(1, "%s: unknown flag %d\n",
2296 tty_name(tty
), flags
);
2300 /* FASYNC if needed ? */
2301 /* If clogged call tty_throttle(tty); */
2305 * gsmld_flush_buffer - clean input queue
2306 * @tty: terminal device
2308 * Flush the input buffer. Called when the line discipline is
2309 * being closed, when the tty layer wants the buffer flushed (eg
2313 static void gsmld_flush_buffer(struct tty_struct
*tty
)
2318 * gsmld_close - close the ldisc for this tty
2321 * Called from the terminal layer when this line discipline is
2322 * being shut down, either because of a close or becsuse of a
2323 * discipline change. The function will not be called while other
2324 * ldisc methods are in progress.
2327 static void gsmld_close(struct tty_struct
*tty
)
2329 struct gsm_mux
*gsm
= tty
->disc_data
;
2331 gsmld_detach_gsm(tty
, gsm
);
2333 gsmld_flush_buffer(tty
);
2334 /* Do other clean up here */
2339 * gsmld_open - open an ldisc
2340 * @tty: terminal to open
2342 * Called when this line discipline is being attached to the
2343 * terminal device. Can sleep. Called serialized so that no
2344 * other events will occur in parallel. No further open will occur
2348 static int gsmld_open(struct tty_struct
*tty
)
2350 struct gsm_mux
*gsm
;
2353 if (tty
->ops
->write
== NULL
)
2356 /* Attach our ldisc data */
2357 gsm
= gsm_alloc_mux();
2361 tty
->disc_data
= gsm
;
2362 tty
->receive_room
= 65536;
2364 /* Attach the initial passive connection */
2367 ret
= gsmld_attach_gsm(tty
, gsm
);
2369 gsm_cleanup_mux(gsm
);
2376 * gsmld_write_wakeup - asynchronous I/O notifier
2379 * Required for the ptys, serial driver etc. since processes
2380 * that attach themselves to the master and rely on ASYNC
2381 * IO must be woken up
2384 static void gsmld_write_wakeup(struct tty_struct
*tty
)
2386 struct gsm_mux
*gsm
= tty
->disc_data
;
2387 unsigned long flags
;
2390 clear_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
2391 spin_lock_irqsave(&gsm
->tx_lock
, flags
);
2393 if (gsm
->tx_bytes
< TX_THRESH_LO
) {
2394 gsm_dlci_data_sweep(gsm
);
2396 spin_unlock_irqrestore(&gsm
->tx_lock
, flags
);
2400 * gsmld_read - read function for tty
2402 * @file: file object
2403 * @buf: userspace buffer pointer
2406 * Perform reads for the line discipline. We are guaranteed that the
2407 * line discipline will not be closed under us but we may get multiple
2408 * parallel readers and must handle this ourselves. We may also get
2409 * a hangup. Always called in user context, may sleep.
2411 * This code must be sure never to sleep through a hangup.
2414 static ssize_t
gsmld_read(struct tty_struct
*tty
, struct file
*file
,
2415 unsigned char __user
*buf
, size_t nr
)
2421 * gsmld_write - write function for tty
2423 * @file: file object
2424 * @buf: userspace buffer pointer
2427 * Called when the owner of the device wants to send a frame
2428 * itself (or some other control data). The data is transferred
2429 * as-is and must be properly framed and checksummed as appropriate
2430 * by userspace. Frames are either sent whole or not at all as this
2431 * avoids pain user side.
2434 static ssize_t
gsmld_write(struct tty_struct
*tty
, struct file
*file
,
2435 const unsigned char *buf
, size_t nr
)
2437 int space
= tty_write_room(tty
);
2439 return tty
->ops
->write(tty
, buf
, nr
);
2440 set_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
2445 * gsmld_poll - poll method for N_GSM0710
2446 * @tty: terminal device
2447 * @file: file accessing it
2450 * Called when the line discipline is asked to poll() for data or
2451 * for special events. This code is not serialized with respect to
2452 * other events save open/close.
2454 * This code must be sure never to sleep through a hangup.
2455 * Called without the kernel lock held - fine
2458 static unsigned int gsmld_poll(struct tty_struct
*tty
, struct file
*file
,
2461 unsigned int mask
= 0;
2462 struct gsm_mux
*gsm
= tty
->disc_data
;
2464 poll_wait(file
, &tty
->read_wait
, wait
);
2465 poll_wait(file
, &tty
->write_wait
, wait
);
2466 if (tty_hung_up_p(file
))
2468 if (!tty_is_writelocked(tty
) && tty_write_room(tty
) > 0)
2469 mask
|= POLLOUT
| POLLWRNORM
;
2475 static int gsmld_config(struct tty_struct
*tty
, struct gsm_mux
*gsm
,
2476 struct gsm_config
*c
)
2479 int need_restart
= 0;
2481 /* Stuff we don't support yet - UI or I frame transport, windowing */
2482 if ((c
->adaption
!= 1 && c
->adaption
!= 2) || c
->k
)
2484 /* Check the MRU/MTU range looks sane */
2485 if (c
->mru
> MAX_MRU
|| c
->mtu
> MAX_MTU
|| c
->mru
< 8 || c
->mtu
< 8)
2489 if (c
->encapsulation
> 1) /* Basic, advanced, no I */
2491 if (c
->initiator
> 1)
2493 if (c
->i
== 0 || c
->i
> 2) /* UIH and UI only */
2496 * See what is needed for reconfiguration
2500 if (c
->t1
!= 0 && c
->t1
!= gsm
->t1
)
2502 if (c
->t2
!= 0 && c
->t2
!= gsm
->t2
)
2504 if (c
->encapsulation
!= gsm
->encoding
)
2506 if (c
->adaption
!= gsm
->adaption
)
2509 if (c
->initiator
!= gsm
->initiator
)
2511 if (c
->mru
!= gsm
->mru
)
2513 if (c
->mtu
!= gsm
->mtu
)
2517 * Close down what is needed, restart and initiate the new
2521 if (need_close
|| need_restart
) {
2522 gsm_dlci_begin_close(gsm
->dlci
[0]);
2523 /* This will timeout if the link is down due to N2 expiring */
2524 wait_event_interruptible(gsm
->event
,
2525 gsm
->dlci
[0]->state
== DLCI_CLOSED
);
2526 if (signal_pending(current
))
2530 gsm_cleanup_mux(gsm
);
2532 gsm
->initiator
= c
->initiator
;
2535 gsm
->encoding
= c
->encapsulation
;
2536 gsm
->adaption
= c
->adaption
;
2549 /* FIXME: We need to separate activation/deactivation from adding
2550 and removing from the mux array */
2552 gsm_activate_mux(gsm
);
2553 if (gsm
->initiator
&& need_close
)
2554 gsm_dlci_begin_open(gsm
->dlci
[0]);
2558 static int gsmld_ioctl(struct tty_struct
*tty
, struct file
*file
,
2559 unsigned int cmd
, unsigned long arg
)
2561 struct gsm_config c
;
2562 struct gsm_mux
*gsm
= tty
->disc_data
;
2565 case GSMIOC_GETCONF
:
2566 memset(&c
, 0, sizeof(c
));
2567 c
.adaption
= gsm
->adaption
;
2568 c
.encapsulation
= gsm
->encoding
;
2569 c
.initiator
= gsm
->initiator
;
2572 c
.t3
= 0; /* Not supported */
2574 if (gsm
->ftype
== UIH
)
2578 pr_debug("Ftype %d i %d\n", gsm
->ftype
, c
.i
);
2582 if (copy_to_user((void *)arg
, &c
, sizeof(c
)))
2585 case GSMIOC_SETCONF
:
2586 if (copy_from_user(&c
, (void *)arg
, sizeof(c
)))
2588 return gsmld_config(tty
, gsm
, &c
);
2590 return n_tty_ioctl_helper(tty
, file
, cmd
, arg
);
2599 static int gsm_mux_net_open(struct net_device
*net
)
2601 pr_debug("%s called\n", __func__
);
2602 netif_start_queue(net
);
2606 static int gsm_mux_net_close(struct net_device
*net
)
2608 netif_stop_queue(net
);
2612 static void dlci_net_free(struct gsm_dlci
*dlci
)
2618 dlci
->adaption
= dlci
->prev_adaption
;
2619 dlci
->data
= dlci
->prev_data
;
2620 free_netdev(dlci
->net
);
2623 static void net_free(struct kref
*ref
)
2625 struct gsm_mux_net
*mux_net
;
2626 struct gsm_dlci
*dlci
;
2628 mux_net
= container_of(ref
, struct gsm_mux_net
, ref
);
2629 dlci
= mux_net
->dlci
;
2632 unregister_netdev(dlci
->net
);
2633 dlci_net_free(dlci
);
2637 static inline void muxnet_get(struct gsm_mux_net
*mux_net
)
2639 kref_get(&mux_net
->ref
);
2642 static inline void muxnet_put(struct gsm_mux_net
*mux_net
)
2644 kref_put(&mux_net
->ref
, net_free
);
2647 static int gsm_mux_net_start_xmit(struct sk_buff
*skb
,
2648 struct net_device
*net
)
2650 struct gsm_mux_net
*mux_net
= netdev_priv(net
);
2651 struct gsm_dlci
*dlci
= mux_net
->dlci
;
2652 muxnet_get(mux_net
);
2654 skb_queue_head(&dlci
->skb_list
, skb
);
2655 net
->stats
.tx_packets
++;
2656 net
->stats
.tx_bytes
+= skb
->len
;
2657 gsm_dlci_data_kick(dlci
);
2658 /* And tell the kernel when the last transmit started. */
2659 netif_trans_update(net
);
2660 muxnet_put(mux_net
);
2661 return NETDEV_TX_OK
;
2664 /* called when a packet did not ack after watchdogtimeout */
2665 static void gsm_mux_net_tx_timeout(struct net_device
*net
)
2667 /* Tell syslog we are hosed. */
2668 dev_dbg(&net
->dev
, "Tx timed out.\n");
2670 /* Update statistics */
2671 net
->stats
.tx_errors
++;
2674 static void gsm_mux_rx_netchar(struct gsm_dlci
*dlci
,
2675 unsigned char *in_buf
, int size
)
2677 struct net_device
*net
= dlci
->net
;
2678 struct sk_buff
*skb
;
2679 struct gsm_mux_net
*mux_net
= netdev_priv(net
);
2680 muxnet_get(mux_net
);
2682 /* Allocate an sk_buff */
2683 skb
= dev_alloc_skb(size
+ NET_IP_ALIGN
);
2685 /* We got no receive buffer. */
2686 net
->stats
.rx_dropped
++;
2687 muxnet_put(mux_net
);
2690 skb_reserve(skb
, NET_IP_ALIGN
);
2691 memcpy(skb_put(skb
, size
), in_buf
, size
);
2694 skb
->protocol
= htons(ETH_P_IP
);
2696 /* Ship it off to the kernel */
2699 /* update out statistics */
2700 net
->stats
.rx_packets
++;
2701 net
->stats
.rx_bytes
+= size
;
2702 muxnet_put(mux_net
);
2706 static void gsm_mux_net_init(struct net_device
*net
)
2708 static const struct net_device_ops gsm_netdev_ops
= {
2709 .ndo_open
= gsm_mux_net_open
,
2710 .ndo_stop
= gsm_mux_net_close
,
2711 .ndo_start_xmit
= gsm_mux_net_start_xmit
,
2712 .ndo_tx_timeout
= gsm_mux_net_tx_timeout
,
2715 net
->netdev_ops
= &gsm_netdev_ops
;
2717 /* fill in the other fields */
2718 net
->watchdog_timeo
= GSM_NET_TX_TIMEOUT
;
2719 net
->flags
= IFF_POINTOPOINT
| IFF_NOARP
| IFF_MULTICAST
;
2720 net
->type
= ARPHRD_NONE
;
2721 net
->tx_queue_len
= 10;
2725 /* caller holds the dlci mutex */
2726 static void gsm_destroy_network(struct gsm_dlci
*dlci
)
2728 struct gsm_mux_net
*mux_net
;
2730 pr_debug("destroy network interface");
2733 mux_net
= netdev_priv(dlci
->net
);
2734 muxnet_put(mux_net
);
2738 /* caller holds the dlci mutex */
2739 static int gsm_create_network(struct gsm_dlci
*dlci
, struct gsm_netconfig
*nc
)
2743 struct net_device
*net
;
2744 struct gsm_mux_net
*mux_net
;
2746 if (!capable(CAP_NET_ADMIN
))
2749 /* Already in a non tty mode */
2750 if (dlci
->adaption
> 2)
2753 if (nc
->protocol
!= htons(ETH_P_IP
))
2754 return -EPROTONOSUPPORT
;
2756 if (nc
->adaption
!= 3 && nc
->adaption
!= 4)
2757 return -EPROTONOSUPPORT
;
2759 pr_debug("create network interface");
2762 if (nc
->if_name
[0] != '\0')
2763 netname
= nc
->if_name
;
2764 net
= alloc_netdev(sizeof(struct gsm_mux_net
), netname
,
2765 NET_NAME_UNKNOWN
, gsm_mux_net_init
);
2767 pr_err("alloc_netdev failed");
2770 net
->mtu
= dlci
->gsm
->mtu
;
2772 net
->max_mtu
= dlci
->gsm
->mtu
;
2773 mux_net
= netdev_priv(net
);
2774 mux_net
->dlci
= dlci
;
2775 kref_init(&mux_net
->ref
);
2776 strncpy(nc
->if_name
, net
->name
, IFNAMSIZ
); /* return net name */
2778 /* reconfigure dlci for network */
2779 dlci
->prev_adaption
= dlci
->adaption
;
2780 dlci
->prev_data
= dlci
->data
;
2781 dlci
->adaption
= nc
->adaption
;
2782 dlci
->data
= gsm_mux_rx_netchar
;
2785 pr_debug("register netdev");
2786 retval
= register_netdev(net
);
2788 pr_err("network register fail %d\n", retval
);
2789 dlci_net_free(dlci
);
2792 return net
->ifindex
; /* return network index */
2795 /* Line discipline for real tty */
2796 static struct tty_ldisc_ops tty_ldisc_packet
= {
2797 .owner
= THIS_MODULE
,
2798 .magic
= TTY_LDISC_MAGIC
,
2801 .close
= gsmld_close
,
2802 .flush_buffer
= gsmld_flush_buffer
,
2804 .write
= gsmld_write
,
2805 .ioctl
= gsmld_ioctl
,
2807 .receive_buf
= gsmld_receive_buf
,
2808 .write_wakeup
= gsmld_write_wakeup
2817 static int gsmtty_modem_update(struct gsm_dlci
*dlci
, u8 brk
)
2820 struct gsm_control
*ctrl
;
2826 modembits
[0] = len
<< 1 | EA
; /* Data bytes */
2827 modembits
[1] = dlci
->addr
<< 2 | 3; /* DLCI, EA, 1 */
2828 modembits
[2] = gsm_encode_modem(dlci
) << 1 | EA
;
2830 modembits
[3] = brk
<< 4 | 2 | EA
; /* Valid, EA */
2831 ctrl
= gsm_control_send(dlci
->gsm
, CMD_MSC
, modembits
, len
+ 1);
2834 return gsm_control_wait(dlci
->gsm
, ctrl
);
2837 static int gsm_carrier_raised(struct tty_port
*port
)
2839 struct gsm_dlci
*dlci
= container_of(port
, struct gsm_dlci
, port
);
2840 /* Not yet open so no carrier info */
2841 if (dlci
->state
!= DLCI_OPEN
)
2845 return dlci
->modem_rx
& TIOCM_CD
;
2848 static void gsm_dtr_rts(struct tty_port
*port
, int onoff
)
2850 struct gsm_dlci
*dlci
= container_of(port
, struct gsm_dlci
, port
);
2851 unsigned int modem_tx
= dlci
->modem_tx
;
2853 modem_tx
|= TIOCM_DTR
| TIOCM_RTS
;
2855 modem_tx
&= ~(TIOCM_DTR
| TIOCM_RTS
);
2856 if (modem_tx
!= dlci
->modem_tx
) {
2857 dlci
->modem_tx
= modem_tx
;
2858 gsmtty_modem_update(dlci
, 0);
2862 static const struct tty_port_operations gsm_port_ops
= {
2863 .carrier_raised
= gsm_carrier_raised
,
2864 .dtr_rts
= gsm_dtr_rts
,
2865 .destruct
= gsm_dlci_free
,
2868 static int gsmtty_install(struct tty_driver
*driver
, struct tty_struct
*tty
)
2870 struct gsm_mux
*gsm
;
2871 struct gsm_dlci
*dlci
;
2872 unsigned int line
= tty
->index
;
2873 unsigned int mux
= line
>> 6;
2881 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2882 if (gsm_mux
[mux
] == NULL
)
2884 if (line
== 0 || line
> 61) /* 62/63 reserved */
2889 /* If DLCI 0 is not yet fully open return an error.
2890 This is ok from a locking
2891 perspective as we don't have to worry about this
2893 mutex_lock(&gsm
->mutex
);
2894 if (gsm
->dlci
[0] && gsm
->dlci
[0]->state
!= DLCI_OPEN
) {
2895 mutex_unlock(&gsm
->mutex
);
2898 dlci
= gsm
->dlci
[line
];
2901 dlci
= gsm_dlci_alloc(gsm
, line
);
2904 mutex_unlock(&gsm
->mutex
);
2907 ret
= tty_port_install(&dlci
->port
, driver
, tty
);
2911 mutex_unlock(&gsm
->mutex
);
2916 dlci_get(gsm
->dlci
[0]);
2918 tty
->driver_data
= dlci
;
2919 mutex_unlock(&gsm
->mutex
);
2924 static int gsmtty_open(struct tty_struct
*tty
, struct file
*filp
)
2926 struct gsm_dlci
*dlci
= tty
->driver_data
;
2927 struct tty_port
*port
= &dlci
->port
;
2930 tty_port_tty_set(port
, tty
);
2933 /* We could in theory open and close before we wait - eg if we get
2934 a DM straight back. This is ok as that will have caused a hangup */
2935 tty_port_set_initialized(port
, 1);
2936 /* Start sending off SABM messages */
2937 gsm_dlci_begin_open(dlci
);
2938 /* And wait for virtual carrier */
2939 return tty_port_block_til_ready(port
, tty
, filp
);
2942 static void gsmtty_close(struct tty_struct
*tty
, struct file
*filp
)
2944 struct gsm_dlci
*dlci
= tty
->driver_data
;
2945 struct gsm_mux
*gsm
;
2949 if (dlci
->state
== DLCI_CLOSED
)
2951 mutex_lock(&dlci
->mutex
);
2952 gsm_destroy_network(dlci
);
2953 mutex_unlock(&dlci
->mutex
);
2955 if (tty_port_close_start(&dlci
->port
, tty
, filp
) == 0)
2957 gsm_dlci_begin_close(dlci
);
2958 if (tty_port_initialized(&dlci
->port
) && C_HUPCL(tty
))
2959 tty_port_lower_dtr_rts(&dlci
->port
);
2960 tty_port_close_end(&dlci
->port
, tty
);
2961 tty_port_tty_set(&dlci
->port
, NULL
);
2965 static void gsmtty_hangup(struct tty_struct
*tty
)
2967 struct gsm_dlci
*dlci
= tty
->driver_data
;
2968 if (dlci
->state
== DLCI_CLOSED
)
2970 tty_port_hangup(&dlci
->port
);
2971 gsm_dlci_begin_close(dlci
);
2974 static int gsmtty_write(struct tty_struct
*tty
, const unsigned char *buf
,
2978 struct gsm_dlci
*dlci
= tty
->driver_data
;
2979 if (dlci
->state
== DLCI_CLOSED
)
2981 /* Stuff the bytes into the fifo queue */
2982 sent
= kfifo_in_locked(dlci
->fifo
, buf
, len
, &dlci
->lock
);
2983 /* Need to kick the channel */
2984 gsm_dlci_data_kick(dlci
);
2988 static int gsmtty_write_room(struct tty_struct
*tty
)
2990 struct gsm_dlci
*dlci
= tty
->driver_data
;
2991 if (dlci
->state
== DLCI_CLOSED
)
2993 return TX_SIZE
- kfifo_len(dlci
->fifo
);
2996 static int gsmtty_chars_in_buffer(struct tty_struct
*tty
)
2998 struct gsm_dlci
*dlci
= tty
->driver_data
;
2999 if (dlci
->state
== DLCI_CLOSED
)
3001 return kfifo_len(dlci
->fifo
);
3004 static void gsmtty_flush_buffer(struct tty_struct
*tty
)
3006 struct gsm_dlci
*dlci
= tty
->driver_data
;
3007 if (dlci
->state
== DLCI_CLOSED
)
3009 /* Caution needed: If we implement reliable transport classes
3010 then the data being transmitted can't simply be junked once
3011 it has first hit the stack. Until then we can just blow it
3013 kfifo_reset(dlci
->fifo
);
3014 /* Need to unhook this DLCI from the transmit queue logic */
3017 static void gsmtty_wait_until_sent(struct tty_struct
*tty
, int timeout
)
3019 /* The FIFO handles the queue so the kernel will do the right
3020 thing waiting on chars_in_buffer before calling us. No work
3024 static int gsmtty_tiocmget(struct tty_struct
*tty
)
3026 struct gsm_dlci
*dlci
= tty
->driver_data
;
3027 if (dlci
->state
== DLCI_CLOSED
)
3029 return dlci
->modem_rx
;
3032 static int gsmtty_tiocmset(struct tty_struct
*tty
,
3033 unsigned int set
, unsigned int clear
)
3035 struct gsm_dlci
*dlci
= tty
->driver_data
;
3036 unsigned int modem_tx
= dlci
->modem_tx
;
3038 if (dlci
->state
== DLCI_CLOSED
)
3043 if (modem_tx
!= dlci
->modem_tx
) {
3044 dlci
->modem_tx
= modem_tx
;
3045 return gsmtty_modem_update(dlci
, 0);
3051 static int gsmtty_ioctl(struct tty_struct
*tty
,
3052 unsigned int cmd
, unsigned long arg
)
3054 struct gsm_dlci
*dlci
= tty
->driver_data
;
3055 struct gsm_netconfig nc
;
3058 if (dlci
->state
== DLCI_CLOSED
)
3061 case GSMIOC_ENABLE_NET
:
3062 if (copy_from_user(&nc
, (void __user
*)arg
, sizeof(nc
)))
3064 nc
.if_name
[IFNAMSIZ
-1] = '\0';
3065 /* return net interface index or error code */
3066 mutex_lock(&dlci
->mutex
);
3067 index
= gsm_create_network(dlci
, &nc
);
3068 mutex_unlock(&dlci
->mutex
);
3069 if (copy_to_user((void __user
*)arg
, &nc
, sizeof(nc
)))
3072 case GSMIOC_DISABLE_NET
:
3073 if (!capable(CAP_NET_ADMIN
))
3075 mutex_lock(&dlci
->mutex
);
3076 gsm_destroy_network(dlci
);
3077 mutex_unlock(&dlci
->mutex
);
3080 return -ENOIOCTLCMD
;
3084 static void gsmtty_set_termios(struct tty_struct
*tty
, struct ktermios
*old
)
3086 struct gsm_dlci
*dlci
= tty
->driver_data
;
3087 if (dlci
->state
== DLCI_CLOSED
)
3089 /* For the moment its fixed. In actual fact the speed information
3090 for the virtual channel can be propogated in both directions by
3091 the RPN control message. This however rapidly gets nasty as we
3092 then have to remap modem signals each way according to whether
3093 our virtual cable is null modem etc .. */
3094 tty_termios_copy_hw(&tty
->termios
, old
);
3097 static void gsmtty_throttle(struct tty_struct
*tty
)
3099 struct gsm_dlci
*dlci
= tty
->driver_data
;
3100 if (dlci
->state
== DLCI_CLOSED
)
3103 dlci
->modem_tx
&= ~TIOCM_DTR
;
3104 dlci
->throttled
= 1;
3105 /* Send an MSC with DTR cleared */
3106 gsmtty_modem_update(dlci
, 0);
3109 static void gsmtty_unthrottle(struct tty_struct
*tty
)
3111 struct gsm_dlci
*dlci
= tty
->driver_data
;
3112 if (dlci
->state
== DLCI_CLOSED
)
3115 dlci
->modem_tx
|= TIOCM_DTR
;
3116 dlci
->throttled
= 0;
3117 /* Send an MSC with DTR set */
3118 gsmtty_modem_update(dlci
, 0);
3121 static int gsmtty_break_ctl(struct tty_struct
*tty
, int state
)
3123 struct gsm_dlci
*dlci
= tty
->driver_data
;
3124 int encode
= 0; /* Off */
3125 if (dlci
->state
== DLCI_CLOSED
)
3128 if (state
== -1) /* "On indefinitely" - we can't encode this
3131 else if (state
> 0) {
3132 encode
= state
/ 200; /* mS to encoding */
3134 encode
= 0x0F; /* Best effort */
3136 return gsmtty_modem_update(dlci
, encode
);
3139 static void gsmtty_cleanup(struct tty_struct
*tty
)
3141 struct gsm_dlci
*dlci
= tty
->driver_data
;
3142 struct gsm_mux
*gsm
= dlci
->gsm
;
3145 dlci_put(gsm
->dlci
[0]);
3149 /* Virtual ttys for the demux */
3150 static const struct tty_operations gsmtty_ops
= {
3151 .install
= gsmtty_install
,
3152 .open
= gsmtty_open
,
3153 .close
= gsmtty_close
,
3154 .write
= gsmtty_write
,
3155 .write_room
= gsmtty_write_room
,
3156 .chars_in_buffer
= gsmtty_chars_in_buffer
,
3157 .flush_buffer
= gsmtty_flush_buffer
,
3158 .ioctl
= gsmtty_ioctl
,
3159 .throttle
= gsmtty_throttle
,
3160 .unthrottle
= gsmtty_unthrottle
,
3161 .set_termios
= gsmtty_set_termios
,
3162 .hangup
= gsmtty_hangup
,
3163 .wait_until_sent
= gsmtty_wait_until_sent
,
3164 .tiocmget
= gsmtty_tiocmget
,
3165 .tiocmset
= gsmtty_tiocmset
,
3166 .break_ctl
= gsmtty_break_ctl
,
3167 .cleanup
= gsmtty_cleanup
,
3172 static int __init
gsm_init(void)
3174 /* Fill in our line protocol discipline, and register it */
3175 int status
= tty_register_ldisc(N_GSM0710
, &tty_ldisc_packet
);
3177 pr_err("n_gsm: can't register line discipline (err = %d)\n",
3182 gsm_tty_driver
= alloc_tty_driver(256);
3183 if (!gsm_tty_driver
) {
3184 tty_unregister_ldisc(N_GSM0710
);
3185 pr_err("gsm_init: tty allocation failed.\n");
3188 gsm_tty_driver
->driver_name
= "gsmtty";
3189 gsm_tty_driver
->name
= "gsmtty";
3190 gsm_tty_driver
->major
= 0; /* Dynamic */
3191 gsm_tty_driver
->minor_start
= 0;
3192 gsm_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
3193 gsm_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
3194 gsm_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
3195 | TTY_DRIVER_HARDWARE_BREAK
;
3196 gsm_tty_driver
->init_termios
= tty_std_termios
;
3198 gsm_tty_driver
->init_termios
.c_lflag
&= ~ECHO
;
3199 tty_set_operations(gsm_tty_driver
, &gsmtty_ops
);
3201 spin_lock_init(&gsm_mux_lock
);
3203 if (tty_register_driver(gsm_tty_driver
)) {
3204 put_tty_driver(gsm_tty_driver
);
3205 tty_unregister_ldisc(N_GSM0710
);
3206 pr_err("gsm_init: tty registration failed.\n");
3209 pr_debug("gsm_init: loaded as %d,%d.\n",
3210 gsm_tty_driver
->major
, gsm_tty_driver
->minor_start
);
3214 static void __exit
gsm_exit(void)
3216 int status
= tty_unregister_ldisc(N_GSM0710
);
3218 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
3220 tty_unregister_driver(gsm_tty_driver
);
3221 put_tty_driver(gsm_tty_driver
);
3224 module_init(gsm_init
);
3225 module_exit(gsm_exit
);
3228 MODULE_LICENSE("GPL");
3229 MODULE_ALIAS_LDISC(N_GSM0710
);