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 ?
25 * Improve the tx engine
26 * Resolve tx side locking by adding a queue_head and routing
27 * all control traffic via it
28 * General tidy/document
29 * Review the locking/move to refcounts more (mux now moved to an
30 * alloc/free model ready)
31 * Use newest tty open/close port helpers and install hooks
32 * What to do about power functions ?
33 * Termios setting and negotiation
34 * Do we need a 'which mux are you' ioctl to correlate mux and tty sets
38 #include <linux/types.h>
39 #include <linux/major.h>
40 #include <linux/errno.h>
41 #include <linux/signal.h>
42 #include <linux/fcntl.h>
43 #include <linux/sched.h>
44 #include <linux/interrupt.h>
45 #include <linux/tty.h>
46 #include <linux/timer.h>
47 #include <linux/ctype.h>
49 #include <linux/string.h>
50 #include <linux/slab.h>
51 #include <linux/poll.h>
52 #include <linux/bitops.h>
53 #include <linux/file.h>
54 #include <linux/uaccess.h>
55 #include <linux/module.h>
56 #include <linux/timer.h>
57 #include <linux/tty_flip.h>
58 #include <linux/tty_driver.h>
59 #include <linux/serial.h>
60 #include <linux/kfifo.h>
61 #include <linux/skbuff.h>
62 #include <linux/gsmmux.h>
65 module_param(debug
, int, 0600);
71 /* Use long timers for testing at low speed with debug on */
77 /* Semi-arbitary buffer size limits. 0710 is normally run with 32-64 byte
78 limits so this is plenty */
83 * Each block of data we have queued to go out is in the form of
84 * a gsm_msg which holds everything we need in a link layer independant
90 u8 addr
; /* DLCI address + flags */
91 u8 ctrl
; /* Control byte + flags */
92 unsigned int len
; /* Length of data block (can be zero) */
93 unsigned char *data
; /* Points into buffer but not at the start */
94 unsigned char buffer
[0];
98 * Each active data link has a gsm_dlci structure associated which ties
99 * the link layer to an optional tty (if the tty side is open). To avoid
100 * complexity right now these are only ever freed up when the mux is
103 * At the moment we don't free DLCI objects until the mux is torn down
104 * this avoid object life time issues but might be worth review later.
111 #define DLCI_CLOSED 0
112 #define DLCI_OPENING 1 /* Sending SABM not seen UA */
113 #define DLCI_OPEN 2 /* SABM/UA complete */
114 #define DLCI_CLOSING 3 /* Sending DISC not seen UA/DM */
117 spinlock_t lock
; /* Protects the internal state */
118 struct timer_list t1
; /* Retransmit timer for SABM and UA */
120 /* Uplink tty if active */
121 struct tty_port port
; /* The tty bound to this DLCI if there is one */
122 struct kfifo
*fifo
; /* Queue fifo for the DLCI */
123 struct kfifo _fifo
; /* For new fifo API porting only */
124 int adaption
; /* Adaption layer in use */
125 u32 modem_rx
; /* Our incoming virtual modem lines */
126 u32 modem_tx
; /* Our outgoing modem lines */
127 int dead
; /* Refuse re-open */
129 int throttled
; /* Private copy of throttle state */
130 int constipated
; /* Throttle status for outgoing */
132 struct sk_buff
*skb
; /* Frame being sent */
133 struct sk_buff_head skb_list
; /* Queued frames */
134 /* Data handling callback */
135 void (*data
)(struct gsm_dlci
*dlci
, u8
*data
, int len
);
138 /* DLCI 0, 62/63 are special or reseved see gsmtty_open */
143 * DLCI 0 is used to pass control blocks out of band of the data
144 * flow (and with a higher link priority). One command can be outstanding
145 * at a time and we use this structure to manage them. They are created
146 * and destroyed by the user context, and updated by the receive paths
151 u8 cmd
; /* Command we are issuing */
152 u8
*data
; /* Data for the command in case we retransmit */
153 int len
; /* Length of block for retransmission */
154 int done
; /* Done flag */
155 int error
; /* Error if any */
159 * Each GSM mux we have is represented by this structure. If we are
160 * operating as an ldisc then we use this structure as our ldisc
161 * state. We need to sort out lifetimes and locking with respect
162 * to the gsm mux array. For now we don't free DLCI objects that
163 * have been instantiated until the mux itself is terminated.
165 * To consider further: tty open versus mux shutdown.
169 struct tty_struct
*tty
; /* The tty our ldisc is bound to */
172 /* Events on the GSM channel */
173 wait_queue_head_t event
;
175 /* Bits for GSM mode decoding */
182 #define GSM_ADDRESS 2
183 #define GSM_CONTROL 3
187 #define GSM_OVERRUN 7
189 unsigned int address
;
195 u8
*txframe
; /* TX framing buffer */
197 /* Methods for the receiver side */
198 void (*receive
)(struct gsm_mux
*gsm
, u8 ch
);
199 void (*error
)(struct gsm_mux
*gsm
, u8 ch
, u8 flag
);
200 /* And transmit side */
201 int (*output
)(struct gsm_mux
*mux
, u8
*data
, int len
);
206 int initiator
; /* Did we initiate connection */
207 int dead
; /* Has the mux been shut down */
208 struct gsm_dlci
*dlci
[NUM_DLCI
];
209 int constipated
; /* Asked by remote to shut up */
212 unsigned int tx_bytes
; /* TX data outstanding */
213 #define TX_THRESH_HI 8192
214 #define TX_THRESH_LO 2048
215 struct gsm_msg
*tx_head
; /* Pending data packets */
216 struct gsm_msg
*tx_tail
;
218 /* Control messages */
219 struct timer_list t2_timer
; /* Retransmit timer for commands */
220 int cretries
; /* Command retry counter */
221 struct gsm_control
*pending_cmd
;/* Our current pending command */
222 spinlock_t control_lock
; /* Protects the pending command */
225 int adaption
; /* 1 or 2 supported */
226 u8 ftype
; /* UI or UIH */
227 int t1
, t2
; /* Timers in 1/100th of a sec */
228 int n2
; /* Retry count */
230 /* Statistics (not currently exposed) */
231 unsigned long bad_fcs
;
232 unsigned long malformed
;
233 unsigned long io_error
;
234 unsigned long bad_size
;
235 unsigned long unsupported
;
240 * Mux objects - needed so that we can translate a tty index into the
241 * relevant mux and DLCI.
244 #define MAX_MUX 4 /* 256 minors */
245 static struct gsm_mux
*gsm_mux
[MAX_MUX
]; /* GSM muxes */
246 static spinlock_t gsm_mux_lock
;
249 * This section of the driver logic implements the GSM encodings
250 * both the basic and the 'advanced'. Reliable transport is not
258 /* I is special: the rest are ..*/
269 /* Channel commands */
271 #define CMD_TEST 0x11
274 #define CMD_FCOFF 0x31
277 #define CMD_FCON 0x51
282 /* Virtual modem bits */
289 #define GSM0_SOF 0xF9
290 #define GSM1_SOF 0x7E
291 #define GSM1_ESCAPE 0x7D
292 #define GSM1_ESCAPE_BITS 0x20
296 static const struct tty_port_operations gsm_port_ops
;
299 * CRC table for GSM 0710
302 static const u8 gsm_fcs8
[256] = {
303 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
304 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
305 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
306 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
307 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
308 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
309 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
310 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
311 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
312 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
313 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
314 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
315 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
316 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
317 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
318 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
319 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
320 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
321 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
322 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
323 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
324 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
325 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
326 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
327 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
328 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
329 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
330 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
331 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
332 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
333 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
334 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
337 #define INIT_FCS 0xFF
338 #define GOOD_FCS 0xCF
341 * gsm_fcs_add - update FCS
345 * Update the FCS to include c. Uses the algorithm in the specification
349 static inline u8
gsm_fcs_add(u8 fcs
, u8 c
)
351 return gsm_fcs8
[fcs
^ c
];
355 * gsm_fcs_add_block - update FCS for a block
358 * @len: length of buffer
360 * Update the FCS to include c. Uses the algorithm in the specification
364 static inline u8
gsm_fcs_add_block(u8 fcs
, u8
*c
, int len
)
367 fcs
= gsm_fcs8
[fcs
^ *c
++];
372 * gsm_read_ea - read a byte into an EA
373 * @val: variable holding value
374 * c: byte going into the EA
376 * Processes one byte of an EA. Updates the passed variable
377 * and returns 1 if the EA is now completely read
380 static int gsm_read_ea(unsigned int *val
, u8 c
)
382 /* Add the next 7 bits into the value */
385 /* Was this the last byte of the EA 1 = yes*/
390 * gsm_encode_modem - encode modem data bits
391 * @dlci: DLCI to encode from
393 * Returns the correct GSM encoded modem status bits (6 bit field) for
394 * the current status of the DLCI and attached tty object
397 static u8
gsm_encode_modem(const struct gsm_dlci
*dlci
)
400 /* FC is true flow control not modem bits */
403 if (dlci
->modem_tx
& TIOCM_DTR
)
404 modembits
|= MDM_RTC
;
405 if (dlci
->modem_tx
& TIOCM_RTS
)
406 modembits
|= MDM_RTR
;
407 if (dlci
->modem_tx
& TIOCM_RI
)
409 if (dlci
->modem_tx
& TIOCM_CD
)
415 * gsm_print_packet - display a frame for debug
416 * @hdr: header to print before decode
417 * @addr: address EA from the frame
418 * @cr: C/R bit from the frame
419 * @control: control including PF bit
420 * @data: following data bytes
421 * @dlen: length of data
423 * Displays a packet in human readable format for debugging purposes. The
424 * style is based on amateur radio LAP-B dump display.
427 static void gsm_print_packet(const char *hdr
, int addr
, int cr
,
428 u8 control
, const u8
*data
, int dlen
)
433 printk(KERN_INFO
"%s %d) %c: ", hdr
, addr
, "RC"[cr
]);
435 switch (control
& ~PF
) {
437 printk(KERN_CONT
"SABM");
440 printk(KERN_CONT
"UA");
443 printk(KERN_CONT
"DISC");
446 printk(KERN_CONT
"DM");
449 printk(KERN_CONT
"UI");
452 printk(KERN_CONT
"UIH");
455 if (!(control
& 0x01)) {
456 printk(KERN_CONT
"I N(S)%d N(R)%d",
457 (control
& 0x0E) >> 1, (control
& 0xE)>> 5);
458 } else switch (control
& 0x0F) {
460 printk("RR(%d)", (control
& 0xE0) >> 5);
463 printk("RNR(%d)", (control
& 0xE0) >> 5);
466 printk("REJ(%d)", (control
& 0xE0) >> 5);
469 printk(KERN_CONT
"[%02X]", control
);
474 printk(KERN_CONT
"(P)");
476 printk(KERN_CONT
"(F)");
482 printk(KERN_CONT
"\n ");
483 printk(KERN_CONT
"%02X ", *data
++);
487 printk(KERN_CONT
"\n");
492 * Link level transmission side
496 * gsm_stuff_packet - bytestuff a packet
499 * @len: length of input
501 * Expand a buffer by bytestuffing it. The worst case size change
502 * is doubling and the caller is responsible for handing out
503 * suitable sized buffers.
506 static int gsm_stuff_frame(const u8
*input
, u8
*output
, int len
)
510 if (*input
== GSM1_SOF
|| *input
== GSM1_ESCAPE
511 || *input
== XON
|| *input
== XOFF
) {
512 *output
++ = GSM1_ESCAPE
;
513 *output
++ = *input
++ ^ GSM1_ESCAPE_BITS
;
516 *output
++ = *input
++;
522 static void hex_packet(const unsigned char *p
, int len
)
525 for (i
= 0; i
< len
; i
++) {
526 if (i
&& (i
% 16) == 0)
528 printk("%02X ", *p
++);
534 * gsm_send - send a control frame
536 * @addr: address for control frame
537 * @cr: command/response bit
538 * @control: control byte including PF bit
540 * Format up and transmit a control frame. These do not go via the
541 * queueing logic as they should be transmitted ahead of data when
544 * FIXME: Lock versus data TX path
547 static void gsm_send(struct gsm_mux
*gsm
, int addr
, int cr
, int control
)
553 switch (gsm
->encoding
) {
556 cbuf
[1] = (addr
<< 2) | (cr
<< 1) | EA
;
558 cbuf
[3] = EA
; /* Length of data = 0 */
559 cbuf
[4] = 0xFF - gsm_fcs_add_block(INIT_FCS
, cbuf
+ 1, 3);
565 /* Control frame + packing (but not frame stuffing) in mode 1 */
566 ibuf
[0] = (addr
<< 2) | (cr
<< 1) | EA
;
568 ibuf
[2] = 0xFF - gsm_fcs_add_block(INIT_FCS
, ibuf
, 2);
569 /* Stuffing may double the size worst case */
570 len
= gsm_stuff_frame(ibuf
, cbuf
+ 1, 3);
571 /* Now add the SOF markers */
573 cbuf
[len
+ 1] = GSM1_SOF
;
574 /* FIXME: we can omit the lead one in many cases */
581 gsm
->output(gsm
, cbuf
, len
);
582 gsm_print_packet("-->", addr
, cr
, control
, NULL
, 0);
586 * gsm_response - send a control response
588 * @addr: address for control frame
589 * @control: control byte including PF bit
591 * Format up and transmit a link level response frame.
594 static inline void gsm_response(struct gsm_mux
*gsm
, int addr
, int control
)
596 gsm_send(gsm
, addr
, 0, control
);
600 * gsm_command - send a control command
602 * @addr: address for control frame
603 * @control: control byte including PF bit
605 * Format up and transmit a link level command frame.
608 static inline void gsm_command(struct gsm_mux
*gsm
, int addr
, int control
)
610 gsm_send(gsm
, addr
, 1, control
);
613 /* Data transmission */
615 #define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
618 * gsm_data_alloc - allocate data frame
620 * @addr: DLCI address
621 * @len: length excluding header and FCS
622 * @ctrl: control byte
624 * Allocate a new data buffer for sending frames with data. Space is left
625 * at the front for header bytes but that is treated as an implementation
626 * detail and not for the high level code to use
629 static struct gsm_msg
*gsm_data_alloc(struct gsm_mux
*gsm
, u8 addr
, int len
,
632 struct gsm_msg
*m
= kmalloc(sizeof(struct gsm_msg
) + len
+ HDR_LEN
,
636 m
->data
= m
->buffer
+ HDR_LEN
- 1; /* Allow for FCS */
645 * gsm_data_kick - poke the queue
648 * The tty device has called us to indicate that room has appeared in
649 * the transmit queue. Ram more data into the pipe if we have any
651 * FIXME: lock against link layer control transmissions
654 static void gsm_data_kick(struct gsm_mux
*gsm
)
656 struct gsm_msg
*msg
= gsm
->tx_head
;
660 /* FIXME: We need to apply this solely to data messages */
661 if (gsm
->constipated
)
664 while (gsm
->tx_head
!= NULL
) {
666 if (gsm
->encoding
!= 0) {
667 gsm
->txframe
[0] = GSM1_SOF
;
668 len
= gsm_stuff_frame(msg
->data
,
669 gsm
->txframe
+ 1, msg
->len
);
670 gsm
->txframe
[len
+ 1] = GSM1_SOF
;
673 gsm
->txframe
[0] = GSM0_SOF
;
674 memcpy(gsm
->txframe
+ 1 , msg
->data
, msg
->len
);
675 gsm
->txframe
[msg
->len
+ 1] = GSM0_SOF
;
680 printk("gsm_data_kick: \n");
681 hex_packet(gsm
->txframe
, len
);
684 if (gsm
->output(gsm
, gsm
->txframe
+ skip_sof
,
687 /* FIXME: Can eliminate one SOF in many more cases */
688 gsm
->tx_head
= msg
->next
;
689 if (gsm
->tx_head
== NULL
)
691 gsm
->tx_bytes
-= msg
->len
;
693 /* For a burst of frames skip the extra SOF within the
700 * __gsm_data_queue - queue a UI or UIH frame
701 * @dlci: DLCI sending the data
702 * @msg: message queued
704 * Add data to the transmit queue and try and get stuff moving
705 * out of the mux tty if not already doing so. The Caller must hold
709 static void __gsm_data_queue(struct gsm_dlci
*dlci
, struct gsm_msg
*msg
)
711 struct gsm_mux
*gsm
= dlci
->gsm
;
713 u8
*fcs
= dp
+ msg
->len
;
715 /* Fill in the header */
716 if (gsm
->encoding
== 0) {
718 *--dp
= (msg
->len
<< 1) | EA
;
720 *--dp
= (msg
->len
>> 7); /* bits 7 - 15 */
721 *--dp
= (msg
->len
& 127) << 1; /* bits 0 - 6 */
727 *--dp
= (msg
->addr
<< 2) | 2 | EA
;
729 *--dp
= (msg
->addr
<< 2) | EA
;
730 *fcs
= gsm_fcs_add_block(INIT_FCS
, dp
, msg
->data
- dp
);
731 /* Ugly protocol layering violation */
732 if (msg
->ctrl
== UI
|| msg
->ctrl
== (UI
|PF
))
733 *fcs
= gsm_fcs_add_block(*fcs
, msg
->data
, msg
->len
);
736 gsm_print_packet("Q> ", msg
->addr
, gsm
->initiator
, msg
->ctrl
,
737 msg
->data
, msg
->len
);
739 /* Move the header back and adjust the length, also allow for the FCS
740 now tacked on the end */
741 msg
->len
+= (msg
->data
- dp
) + 1;
744 /* Add to the actual output queue */
746 gsm
->tx_tail
->next
= msg
;
750 gsm
->tx_bytes
+= msg
->len
;
755 * gsm_data_queue - queue a UI or UIH frame
756 * @dlci: DLCI sending the data
757 * @msg: message queued
759 * Add data to the transmit queue and try and get stuff moving
760 * out of the mux tty if not already doing so. Take the
761 * the gsm tx lock and dlci lock.
764 static void gsm_data_queue(struct gsm_dlci
*dlci
, struct gsm_msg
*msg
)
767 spin_lock_irqsave(&dlci
->gsm
->tx_lock
, flags
);
768 __gsm_data_queue(dlci
, msg
);
769 spin_unlock_irqrestore(&dlci
->gsm
->tx_lock
, flags
);
773 * gsm_dlci_data_output - try and push data out of a DLCI
775 * @dlci: the DLCI to pull data from
777 * Pull data from a DLCI and send it into the transmit queue if there
778 * is data. Keep to the MRU of the mux. This path handles the usual tty
779 * interface which is a byte stream with optional modem data.
781 * Caller must hold the tx_lock of the mux.
784 static int gsm_dlci_data_output(struct gsm_mux
*gsm
, struct gsm_dlci
*dlci
)
789 int h
= dlci
->adaption
- 1;
791 len
= kfifo_len(dlci
->fifo
);
795 /* MTU/MRU count only the data bits */
801 msg
= gsm_data_alloc(gsm
, dlci
->addr
, size
, gsm
->ftype
);
802 /* FIXME: need a timer or something to kick this so it can't
803 get stuck with no work outstanding and no buffer free */
807 switch (dlci
->adaption
) {
808 case 1: /* Unstructured */
810 case 2: /* Unstructed with modem bits. Always one byte as we never
811 send inline break data */
812 *dp
+= gsm_encode_modem(dlci
);
816 WARN_ON(kfifo_out_locked(dlci
->fifo
, dp
, len
, &dlci
->lock
) != len
);
817 __gsm_data_queue(dlci
, msg
);
818 /* Bytes of data we used up */
823 * gsm_dlci_data_output_framed - try and push data out of a DLCI
825 * @dlci: the DLCI to pull data from
827 * Pull data from a DLCI and send it into the transmit queue if there
828 * is data. Keep to the MRU of the mux. This path handles framed data
829 * queued as skbuffs to the DLCI.
831 * Caller must hold the tx_lock of the mux.
834 static int gsm_dlci_data_output_framed(struct gsm_mux
*gsm
,
835 struct gsm_dlci
*dlci
)
840 int last
= 0, first
= 0;
843 /* One byte per frame is used for B/F flags */
844 if (dlci
->adaption
== 4)
847 /* dlci->skb is locked by tx_lock */
848 if (dlci
->skb
== NULL
) {
849 dlci
->skb
= skb_dequeue(&dlci
->skb_list
);
850 if (dlci
->skb
== NULL
)
854 len
= dlci
->skb
->len
+ overhead
;
856 /* MTU/MRU count only the data bits */
857 if (len
> gsm
->mtu
) {
858 if (dlci
->adaption
== 3) {
859 /* Over long frame, bin it */
860 kfree_skb(dlci
->skb
);
868 size
= len
+ overhead
;
869 msg
= gsm_data_alloc(gsm
, dlci
->addr
, size
, gsm
->ftype
);
871 /* FIXME: need a timer or something to kick this so it can't
872 get stuck with no work outstanding and no buffer free */
877 if (dlci
->adaption
== 4) { /* Interruptible framed (Packetised Data) */
878 /* Flag byte to carry the start/end info */
879 *dp
++ = last
<< 7 | first
<< 6 | 1; /* EA */
882 memcpy(dp
, skb_pull(dlci
->skb
, len
), len
);
883 __gsm_data_queue(dlci
, msg
);
890 * gsm_dlci_data_sweep - look for data to send
893 * Sweep the GSM mux channels in priority order looking for ones with
894 * data to send. We could do with optimising this scan a bit. We aim
895 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
896 * TX_THRESH_LO we get called again
898 * FIXME: We should round robin between groups and in theory you can
899 * renegotiate DLCI priorities with optional stuff. Needs optimising.
902 static void gsm_dlci_data_sweep(struct gsm_mux
*gsm
)
905 /* Priority ordering: We should do priority with RR of the groups */
908 while (i
< NUM_DLCI
) {
909 struct gsm_dlci
*dlci
;
911 if (gsm
->tx_bytes
> TX_THRESH_HI
)
914 if (dlci
== NULL
|| dlci
->constipated
) {
918 if (dlci
->adaption
< 3)
919 len
= gsm_dlci_data_output(gsm
, dlci
);
921 len
= gsm_dlci_data_output_framed(gsm
, dlci
);
924 /* DLCI empty - try the next */
931 * gsm_dlci_data_kick - transmit if possible
932 * @dlci: DLCI to kick
934 * Transmit data from this DLCI if the queue is empty. We can't rely on
935 * a tty wakeup except when we filled the pipe so we need to fire off
936 * new data ourselves in other cases.
939 static void gsm_dlci_data_kick(struct gsm_dlci
*dlci
)
943 spin_lock_irqsave(&dlci
->gsm
->tx_lock
, flags
);
944 /* If we have nothing running then we need to fire up */
945 if (dlci
->gsm
->tx_bytes
== 0)
946 gsm_dlci_data_output(dlci
->gsm
, dlci
);
947 else if (dlci
->gsm
->tx_bytes
< TX_THRESH_LO
)
948 gsm_dlci_data_sweep(dlci
->gsm
);
949 spin_unlock_irqrestore(&dlci
->gsm
->tx_lock
, flags
);
953 * Control message processing
958 * gsm_control_reply - send a response frame to a control
960 * @cmd: the command to use
961 * @data: data to follow encoded info
962 * @dlen: length of data
964 * Encode up and queue a UI/UIH frame containing our response.
967 static void gsm_control_reply(struct gsm_mux
*gsm
, int cmd
, u8
*data
,
971 msg
= gsm_data_alloc(gsm
, 0, dlen
+ 2, gsm
->ftype
);
974 msg
->data
[0] = (cmd
& 0xFE) << 1 | EA
; /* Clear C/R */
975 msg
->data
[1] = (dlen
<< 1) | EA
;
976 memcpy(msg
->data
+ 2, data
, dlen
);
977 gsm_data_queue(gsm
->dlci
[0], msg
);
981 * gsm_process_modem - process received modem status
982 * @tty: virtual tty bound to the DLCI
983 * @dlci: DLCI to affect
984 * @modem: modem bits (full EA)
986 * Used when a modem control message or line state inline in adaption
987 * layer 2 is processed. Sort out the local modem state and throttles
990 static void gsm_process_modem(struct tty_struct
*tty
, struct gsm_dlci
*dlci
,
996 /* Flow control/ready to communicate */
997 if (modem
& MDM_FC
) {
998 /* Need to throttle our output on this device */
999 dlci
->constipated
= 1;
1001 if (modem
& MDM_RTC
) {
1002 mlines
|= TIOCM_DSR
| TIOCM_DTR
;
1003 dlci
->constipated
= 0;
1004 gsm_dlci_data_kick(dlci
);
1006 /* Map modem bits */
1007 if (modem
& MDM_RTR
)
1008 mlines
|= TIOCM_RTS
| TIOCM_CTS
;
1014 /* Carrier drop -> hangup */
1016 if ((mlines
& TIOCM_CD
) == 0 && (dlci
->modem_rx
& TIOCM_CD
))
1017 if (!(tty
->termios
->c_cflag
& CLOCAL
))
1020 tty_insert_flip_char(tty
, 0, TTY_BREAK
);
1022 dlci
->modem_rx
= mlines
;
1026 * gsm_control_modem - modem status received
1028 * @data: data following command
1029 * @clen: command length
1031 * We have received a modem status control message. This is used by
1032 * the GSM mux protocol to pass virtual modem line status and optionally
1033 * to indicate break signals. Unpack it, convert to Linux representation
1034 * and if need be stuff a break message down the tty.
1037 static void gsm_control_modem(struct gsm_mux
*gsm
, u8
*data
, int clen
)
1039 unsigned int addr
= 0;
1040 unsigned int modem
= 0;
1041 struct gsm_dlci
*dlci
;
1044 struct tty_struct
*tty
;
1046 while (gsm_read_ea(&addr
, *dp
++) == 0) {
1051 /* Must be at least one byte following the EA */
1057 /* Closed port, or invalid ? */
1058 if (addr
== 0 || addr
>= NUM_DLCI
|| gsm
->dlci
[addr
] == NULL
)
1060 dlci
= gsm
->dlci
[addr
];
1062 while (gsm_read_ea(&modem
, *dp
++) == 0) {
1067 tty
= tty_port_tty_get(&dlci
->port
);
1068 gsm_process_modem(tty
, dlci
, modem
);
1073 gsm_control_reply(gsm
, CMD_MSC
, data
, clen
);
1077 * gsm_control_rls - remote line status
1080 * @clen: data length
1082 * The modem sends us a two byte message on the control channel whenever
1083 * it wishes to send us an error state from the virtual link. Stuff
1084 * this into the uplink tty if present
1087 static void gsm_control_rls(struct gsm_mux
*gsm
, u8
*data
, int clen
)
1089 struct tty_struct
*tty
;
1090 unsigned int addr
= 0 ;
1095 while (gsm_read_ea(&addr
, *dp
++) == 0) {
1100 /* Must be at least one byte following ea */
1105 /* Closed port, or invalid ? */
1106 if (addr
== 0 || addr
>= NUM_DLCI
|| gsm
->dlci
[addr
] == NULL
)
1110 if ((bits
& 1) == 0)
1112 /* See if we have an uplink tty */
1113 tty
= tty_port_tty_get(&gsm
->dlci
[addr
]->port
);
1117 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
1119 tty_insert_flip_char(tty
, 0, TTY_PARITY
);
1121 tty_insert_flip_char(tty
, 0, TTY_FRAME
);
1122 tty_flip_buffer_push(tty
);
1125 gsm_control_reply(gsm
, CMD_RLS
, data
, clen
);
1128 static void gsm_dlci_begin_close(struct gsm_dlci
*dlci
);
1131 * gsm_control_message - DLCI 0 control processing
1133 * @command: the command EA
1134 * @data: data beyond the command/length EAs
1137 * Input processor for control messages from the other end of the link.
1138 * Processes the incoming request and queues a response frame or an
1139 * NSC response if not supported
1142 static void gsm_control_message(struct gsm_mux
*gsm
, unsigned int command
,
1148 struct gsm_dlci
*dlci
= gsm
->dlci
[0];
1149 /* Modem wishes to close down */
1153 gsm_dlci_begin_close(dlci
);
1158 /* Modem wishes to test, reply with the data */
1159 gsm_control_reply(gsm
, CMD_TEST
, data
, clen
);
1162 /* Modem wants us to STFU */
1163 gsm
->constipated
= 1;
1164 gsm_control_reply(gsm
, CMD_FCON
, NULL
, 0);
1167 /* Modem can accept data again */
1168 gsm
->constipated
= 0;
1169 gsm_control_reply(gsm
, CMD_FCOFF
, NULL
, 0);
1170 /* Kick the link in case it is idling */
1174 /* Out of band modem line change indicator for a DLCI */
1175 gsm_control_modem(gsm
, data
, clen
);
1178 /* Out of band error reception for a DLCI */
1179 gsm_control_rls(gsm
, data
, clen
);
1182 /* Modem wishes to enter power saving state */
1183 gsm_control_reply(gsm
, CMD_PSC
, NULL
, 0);
1185 /* Optional unsupported commands */
1186 case CMD_PN
: /* Parameter negotiation */
1187 case CMD_RPN
: /* Remote port negotation */
1188 case CMD_SNC
: /* Service negotation command */
1190 /* Reply to bad commands with an NSC */
1192 gsm_control_reply(gsm
, CMD_NSC
, buf
, 1);
1198 * gsm_control_response - process a response to our control
1200 * @command: the command (response) EA
1201 * @data: data beyond the command/length EA
1204 * Process a response to an outstanding command. We only allow a single
1205 * control message in flight so this is fairly easy. All the clean up
1206 * is done by the caller, we just update the fields, flag it as done
1210 static void gsm_control_response(struct gsm_mux
*gsm
, unsigned int command
,
1213 struct gsm_control
*ctrl
;
1214 unsigned long flags
;
1216 spin_lock_irqsave(&gsm
->control_lock
, flags
);
1218 ctrl
= gsm
->pending_cmd
;
1219 /* Does the reply match our command */
1221 if (ctrl
!= NULL
&& (command
== ctrl
->cmd
|| command
== CMD_NSC
)) {
1222 /* Our command was replied to, kill the retry timer */
1223 del_timer(&gsm
->t2_timer
);
1224 gsm
->pending_cmd
= NULL
;
1225 /* Rejected by the other end */
1226 if (command
== CMD_NSC
)
1227 ctrl
->error
= -EOPNOTSUPP
;
1229 wake_up(&gsm
->event
);
1231 spin_unlock_irqrestore(&gsm
->control_lock
, flags
);
1235 * gsm_control_transmit - send control packet
1237 * @ctrl: frame to send
1239 * Send out a pending control command (called under control lock)
1242 static void gsm_control_transmit(struct gsm_mux
*gsm
, struct gsm_control
*ctrl
)
1244 struct gsm_msg
*msg
= gsm_data_alloc(gsm
, 0, ctrl
->len
+ 1,
1248 msg
->data
[0] = (ctrl
->cmd
<< 1) | 2 | EA
; /* command */
1249 memcpy(msg
->data
+ 1, ctrl
->data
, ctrl
->len
);
1250 gsm_data_queue(gsm
->dlci
[0], msg
);
1254 * gsm_control_retransmit - retransmit a control frame
1255 * @data: pointer to our gsm object
1257 * Called off the T2 timer expiry in order to retransmit control frames
1258 * that have been lost in the system somewhere. The control_lock protects
1259 * us from colliding with another sender or a receive completion event.
1260 * In that situation the timer may still occur in a small window but
1261 * gsm->pending_cmd will be NULL and we just let the timer expire.
1264 static void gsm_control_retransmit(unsigned long data
)
1266 struct gsm_mux
*gsm
= (struct gsm_mux
*)data
;
1267 struct gsm_control
*ctrl
;
1268 unsigned long flags
;
1269 spin_lock_irqsave(&gsm
->control_lock
, flags
);
1270 ctrl
= gsm
->pending_cmd
;
1273 if (gsm
->cretries
== 0) {
1274 gsm
->pending_cmd
= NULL
;
1275 ctrl
->error
= -ETIMEDOUT
;
1277 spin_unlock_irqrestore(&gsm
->control_lock
, flags
);
1278 wake_up(&gsm
->event
);
1281 gsm_control_transmit(gsm
, ctrl
);
1282 mod_timer(&gsm
->t2_timer
, jiffies
+ gsm
->t2
* HZ
/ 100);
1284 spin_unlock_irqrestore(&gsm
->control_lock
, flags
);
1288 * gsm_control_send - send a control frame on DLCI 0
1289 * @gsm: the GSM channel
1290 * @command: command to send including CR bit
1291 * @data: bytes of data (must be kmalloced)
1292 * @len: length of the block to send
1294 * Queue and dispatch a control command. Only one command can be
1295 * active at a time. In theory more can be outstanding but the matching
1296 * gets really complicated so for now stick to one outstanding.
1299 static struct gsm_control
*gsm_control_send(struct gsm_mux
*gsm
,
1300 unsigned int command
, u8
*data
, int clen
)
1302 struct gsm_control
*ctrl
= kzalloc(sizeof(struct gsm_control
),
1304 unsigned long flags
;
1308 wait_event(gsm
->event
, gsm
->pending_cmd
== NULL
);
1309 spin_lock_irqsave(&gsm
->control_lock
, flags
);
1310 if (gsm
->pending_cmd
!= NULL
) {
1311 spin_unlock_irqrestore(&gsm
->control_lock
, flags
);
1314 ctrl
->cmd
= command
;
1317 gsm
->pending_cmd
= ctrl
;
1318 gsm
->cretries
= gsm
->n2
;
1319 mod_timer(&gsm
->t2_timer
, jiffies
+ gsm
->t2
* HZ
/ 100);
1320 gsm_control_transmit(gsm
, ctrl
);
1321 spin_unlock_irqrestore(&gsm
->control_lock
, flags
);
1326 * gsm_control_wait - wait for a control to finish
1328 * @control: control we are waiting on
1330 * Waits for the control to complete or time out. Frees any used
1331 * resources and returns 0 for success, or an error if the remote
1332 * rejected or ignored the request.
1335 static int gsm_control_wait(struct gsm_mux
*gsm
, struct gsm_control
*control
)
1338 wait_event(gsm
->event
, control
->done
== 1);
1339 err
= control
->error
;
1346 * DLCI level handling: Needs krefs
1350 * State transitions and timers
1354 * gsm_dlci_close - a DLCI has closed
1355 * @dlci: DLCI that closed
1357 * Perform processing when moving a DLCI into closed state. If there
1358 * is an attached tty this is hung up
1361 static void gsm_dlci_close(struct gsm_dlci
*dlci
)
1363 del_timer(&dlci
->t1
);
1365 printk("DLCI %d goes closed.\n", dlci
->addr
);
1366 dlci
->state
= DLCI_CLOSED
;
1367 if (dlci
->addr
!= 0) {
1368 struct tty_struct
*tty
= tty_port_tty_get(&dlci
->port
);
1373 kfifo_reset(dlci
->fifo
);
1375 dlci
->gsm
->dead
= 1;
1376 wake_up(&dlci
->gsm
->event
);
1377 /* A DLCI 0 close is a MUX termination so we need to kick that
1378 back to userspace somehow */
1382 * gsm_dlci_open - a DLCI has opened
1383 * @dlci: DLCI that opened
1385 * Perform processing when moving a DLCI into open state.
1388 static void gsm_dlci_open(struct gsm_dlci
*dlci
)
1390 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1392 del_timer(&dlci
->t1
);
1393 /* This will let a tty open continue */
1394 dlci
->state
= DLCI_OPEN
;
1396 printk("DLCI %d goes open.\n", dlci
->addr
);
1397 wake_up(&dlci
->gsm
->event
);
1401 * gsm_dlci_t1 - T1 timer expiry
1402 * @dlci: DLCI that opened
1404 * The T1 timer handles retransmits of control frames (essentially of
1405 * SABM and DISC). We resend the command until the retry count runs out
1406 * in which case an opening port goes back to closed and a closing port
1407 * is simply put into closed state (any further frames from the other
1408 * end will get a DM response)
1411 static void gsm_dlci_t1(unsigned long data
)
1413 struct gsm_dlci
*dlci
= (struct gsm_dlci
*)data
;
1414 struct gsm_mux
*gsm
= dlci
->gsm
;
1416 switch (dlci
->state
) {
1419 if (dlci
->retries
) {
1420 gsm_command(dlci
->gsm
, dlci
->addr
, SABM
|PF
);
1421 mod_timer(&dlci
->t1
, jiffies
+ gsm
->t1
* HZ
/ 100);
1423 gsm_dlci_close(dlci
);
1427 if (dlci
->retries
) {
1428 gsm_command(dlci
->gsm
, dlci
->addr
, DISC
|PF
);
1429 mod_timer(&dlci
->t1
, jiffies
+ gsm
->t1
* HZ
/ 100);
1431 gsm_dlci_close(dlci
);
1437 * gsm_dlci_begin_open - start channel open procedure
1438 * @dlci: DLCI to open
1440 * Commence opening a DLCI from the Linux side. We issue SABM messages
1441 * to the modem which should then reply with a UA, at which point we
1442 * will move into open state. Opening is done asynchronously with retry
1443 * running off timers and the responses.
1446 static void gsm_dlci_begin_open(struct gsm_dlci
*dlci
)
1448 struct gsm_mux
*gsm
= dlci
->gsm
;
1449 if (dlci
->state
== DLCI_OPEN
|| dlci
->state
== DLCI_OPENING
)
1451 dlci
->retries
= gsm
->n2
;
1452 dlci
->state
= DLCI_OPENING
;
1453 gsm_command(dlci
->gsm
, dlci
->addr
, SABM
|PF
);
1454 mod_timer(&dlci
->t1
, jiffies
+ gsm
->t1
* HZ
/ 100);
1458 * gsm_dlci_begin_close - start channel open procedure
1459 * @dlci: DLCI to open
1461 * Commence closing a DLCI from the Linux side. We issue DISC messages
1462 * to the modem which should then reply with a UA, at which point we
1463 * will move into closed state. Closing is done asynchronously with retry
1464 * off timers. We may also receive a DM reply from the other end which
1465 * indicates the channel was already closed.
1468 static void gsm_dlci_begin_close(struct gsm_dlci
*dlci
)
1470 struct gsm_mux
*gsm
= dlci
->gsm
;
1471 if (dlci
->state
== DLCI_CLOSED
|| dlci
->state
== DLCI_CLOSING
)
1473 dlci
->retries
= gsm
->n2
;
1474 dlci
->state
= DLCI_CLOSING
;
1475 gsm_command(dlci
->gsm
, dlci
->addr
, DISC
|PF
);
1476 mod_timer(&dlci
->t1
, jiffies
+ gsm
->t1
* HZ
/ 100);
1480 * gsm_dlci_data - data arrived
1482 * @data: block of bytes received
1483 * @len: length of received block
1485 * A UI or UIH frame has arrived which contains data for a channel
1486 * other than the control channel. If the relevant virtual tty is
1487 * open we shovel the bits down it, if not we drop them.
1490 static void gsm_dlci_data(struct gsm_dlci
*dlci
, u8
*data
, int len
)
1493 struct tty_port
*port
= &dlci
->port
;
1494 struct tty_struct
*tty
= tty_port_tty_get(port
);
1495 unsigned int modem
= 0;
1498 printk("%d bytes for tty %p\n", len
, tty
);
1500 switch (dlci
->adaption
) {
1501 /* Unsupported types */
1502 /* Packetised interruptible data */
1505 /* Packetised uininterruptible voice/data */
1508 /* Asynchronous serial with line state in each frame */
1510 while (gsm_read_ea(&modem
, *data
++) == 0) {
1515 gsm_process_modem(tty
, dlci
, modem
);
1516 /* Line state will go via DLCI 0 controls only */
1519 tty_insert_flip_string(tty
, data
, len
);
1520 tty_flip_buffer_push(tty
);
1527 * gsm_dlci_control - data arrived on control channel
1529 * @data: block of bytes received
1530 * @len: length of received block
1532 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1533 * control channel. This should contain a command EA followed by
1534 * control data bytes. The command EA contains a command/response bit
1535 * and we divide up the work accordingly.
1538 static void gsm_dlci_command(struct gsm_dlci
*dlci
, u8
*data
, int len
)
1540 /* See what command is involved */
1541 unsigned int command
= 0;
1543 if (gsm_read_ea(&command
, *data
++) == 1) {
1546 /* FIXME: this is properly an EA */
1548 /* Malformed command ? */
1552 gsm_control_message(dlci
->gsm
, command
,
1555 gsm_control_response(dlci
->gsm
, command
,
1563 * Allocate/Free DLCI channels
1567 * gsm_dlci_alloc - allocate a DLCI
1569 * @addr: address of the DLCI
1571 * Allocate and install a new DLCI object into the GSM mux.
1573 * FIXME: review locking races
1576 static struct gsm_dlci
*gsm_dlci_alloc(struct gsm_mux
*gsm
, int addr
)
1578 struct gsm_dlci
*dlci
= kzalloc(sizeof(struct gsm_dlci
), GFP_ATOMIC
);
1581 spin_lock_init(&dlci
->lock
);
1582 dlci
->fifo
= &dlci
->_fifo
;
1583 if (kfifo_alloc(&dlci
->_fifo
, 4096, GFP_KERNEL
) < 0) {
1588 skb_queue_head_init(&dlci
->skb_list
);
1589 init_timer(&dlci
->t1
);
1590 dlci
->t1
.function
= gsm_dlci_t1
;
1591 dlci
->t1
.data
= (unsigned long)dlci
;
1592 tty_port_init(&dlci
->port
);
1593 dlci
->port
.ops
= &gsm_port_ops
;
1596 dlci
->adaption
= gsm
->adaption
;
1597 dlci
->state
= DLCI_CLOSED
;
1599 dlci
->data
= gsm_dlci_data
;
1601 dlci
->data
= gsm_dlci_command
;
1602 gsm
->dlci
[addr
] = dlci
;
1607 * gsm_dlci_free - release DLCI
1608 * @dlci: DLCI to destroy
1610 * Free up a DLCI. Currently to keep the lifetime rules sane we only
1611 * clean up DLCI objects when the MUX closes rather than as the port
1612 * is closed down on both the tty and mux levels.
1616 static void gsm_dlci_free(struct gsm_dlci
*dlci
)
1618 struct tty_struct
*tty
= tty_port_tty_get(&dlci
->port
);
1623 del_timer_sync(&dlci
->t1
);
1624 dlci
->gsm
->dlci
[dlci
->addr
] = NULL
;
1625 kfifo_free(dlci
->fifo
);
1631 * LAPBish link layer logic
1635 * gsm_queue - a GSM frame is ready to process
1636 * @gsm: pointer to our gsm mux
1638 * At this point in time a frame has arrived and been demangled from
1639 * the line encoding. All the differences between the encodings have
1640 * been handled below us and the frame is unpacked into the structures.
1641 * The fcs holds the header FCS but any data FCS must be added here.
1644 static void gsm_queue(struct gsm_mux
*gsm
)
1646 struct gsm_dlci
*dlci
;
1649 /* We have to sneak a look at the packet body to do the FCS.
1650 A somewhat layering violation in the spec */
1652 if ((gsm
->control
& ~PF
) == UI
)
1653 gsm
->fcs
= gsm_fcs_add_block(gsm
->fcs
, gsm
->buf
, gsm
->len
);
1654 if (gsm
->fcs
!= GOOD_FCS
) {
1657 printk("BAD FCS %02x\n", gsm
->fcs
);
1660 address
= gsm
->address
>> 1;
1661 if (address
>= NUM_DLCI
)
1664 cr
= gsm
->address
& 1; /* C/R bit */
1666 gsm_print_packet("<--", address
, cr
, gsm
->control
, gsm
->buf
, gsm
->len
);
1668 cr
^= 1 - gsm
->initiator
; /* Flip so 1 always means command */
1669 dlci
= gsm
->dlci
[address
];
1671 switch (gsm
->control
) {
1676 dlci
= gsm_dlci_alloc(gsm
, address
);
1680 gsm_response(gsm
, address
, DM
);
1682 gsm_response(gsm
, address
, UA
);
1683 gsm_dlci_open(dlci
);
1689 if (dlci
== NULL
|| dlci
->state
== DLCI_CLOSED
) {
1690 gsm_response(gsm
, address
, DM
);
1693 /* Real close complete */
1694 gsm_response(gsm
, address
, UA
);
1695 gsm_dlci_close(dlci
);
1699 if (cr
== 0 || dlci
== NULL
)
1701 switch (dlci
->state
) {
1703 gsm_dlci_close(dlci
);
1706 gsm_dlci_open(dlci
);
1710 case DM
: /* DM can be valid unsolicited */
1716 gsm_dlci_close(dlci
);
1726 if (dlci
== NULL
|| dlci
->state
!= DLCI_OPEN
) {
1727 gsm_command(gsm
, address
, DM
|PF
);
1730 dlci
->data(dlci
, gsm
->buf
, gsm
->len
);
1743 * gsm0_receive - perform processing for non-transparency
1744 * @gsm: gsm data for this ldisc instance
1747 * Receive bytes in gsm mode 0
1750 static void gsm0_receive(struct gsm_mux
*gsm
, unsigned char c
)
1752 switch (gsm
->state
) {
1753 case GSM_SEARCH
: /* SOF marker */
1754 if (c
== GSM0_SOF
) {
1755 gsm
->state
= GSM_ADDRESS
;
1758 gsm
->fcs
= INIT_FCS
;
1760 break; /* Address EA */
1762 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, c
);
1763 if (gsm_read_ea(&gsm
->address
, c
))
1764 gsm
->state
= GSM_CONTROL
;
1766 case GSM_CONTROL
: /* Control Byte */
1767 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, c
);
1769 gsm
->state
= GSM_LEN
;
1771 case GSM_LEN
: /* Length EA */
1772 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, c
);
1773 if (gsm_read_ea(&gsm
->len
, c
)) {
1774 if (gsm
->len
> gsm
->mru
) {
1776 gsm
->state
= GSM_SEARCH
;
1780 gsm
->state
= GSM_DATA
;
1783 case GSM_DATA
: /* Data */
1784 gsm
->buf
[gsm
->count
++] = c
;
1785 if (gsm
->count
== gsm
->len
)
1786 gsm
->state
= GSM_FCS
;
1788 case GSM_FCS
: /* FCS follows the packet */
1791 /* And then back for the next frame */
1792 gsm
->state
= GSM_SEARCH
;
1798 * gsm0_receive - perform processing for non-transparency
1799 * @gsm: gsm data for this ldisc instance
1802 * Receive bytes in mode 1 (Advanced option)
1805 static void gsm1_receive(struct gsm_mux
*gsm
, unsigned char c
)
1807 if (c
== GSM1_SOF
) {
1808 /* EOF is only valid in frame if we have got to the data state
1809 and received at least one byte (the FCS) */
1810 if (gsm
->state
== GSM_DATA
&& gsm
->count
) {
1811 /* Extract the FCS */
1813 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, gsm
->buf
[gsm
->count
]);
1814 gsm
->len
= gsm
->count
;
1816 gsm
->state
= GSM_START
;
1819 /* Any partial frame was a runt so go back to start */
1820 if (gsm
->state
!= GSM_START
) {
1822 gsm
->state
= GSM_START
;
1824 /* A SOF in GSM_START means we are still reading idling or
1829 if (c
== GSM1_ESCAPE
) {
1834 /* Only an unescaped SOF gets us out of GSM search */
1835 if (gsm
->state
== GSM_SEARCH
)
1839 c
^= GSM1_ESCAPE_BITS
;
1842 switch (gsm
->state
) {
1843 case GSM_START
: /* First byte after SOF */
1845 gsm
->state
= GSM_ADDRESS
;
1846 gsm
->fcs
= INIT_FCS
;
1848 case GSM_ADDRESS
: /* Address continuation */
1849 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, c
);
1850 if (gsm_read_ea(&gsm
->address
, c
))
1851 gsm
->state
= GSM_CONTROL
;
1853 case GSM_CONTROL
: /* Control Byte */
1854 gsm
->fcs
= gsm_fcs_add(gsm
->fcs
, c
);
1857 gsm
->state
= GSM_DATA
;
1859 case GSM_DATA
: /* Data */
1860 if (gsm
->count
> gsm
->mru
) { /* Allow one for the FCS */
1861 gsm
->state
= GSM_OVERRUN
;
1864 gsm
->buf
[gsm
->count
++] = c
;
1866 case GSM_OVERRUN
: /* Over-long - eg a dropped SOF */
1872 * gsm_error - handle tty error
1874 * @data: byte received (may be invalid)
1875 * @flag: error received
1877 * Handle an error in the receipt of data for a frame. Currently we just
1878 * go back to hunting for a SOF.
1880 * FIXME: better diagnostics ?
1883 static void gsm_error(struct gsm_mux
*gsm
,
1884 unsigned char data
, unsigned char flag
)
1886 gsm
->state
= GSM_SEARCH
;
1891 * gsm_cleanup_mux - generic GSM protocol cleanup
1894 * Clean up the bits of the mux which are the same for all framing
1895 * protocols. Remove the mux from the mux table, stop all the timers
1896 * and then shut down each device hanging up the channels as we go.
1899 void gsm_cleanup_mux(struct gsm_mux
*gsm
)
1902 struct gsm_dlci
*dlci
= gsm
->dlci
[0];
1903 struct gsm_msg
*txq
;
1907 spin_lock(&gsm_mux_lock
);
1908 for (i
= 0; i
< MAX_MUX
; i
++) {
1909 if (gsm_mux
[i
] == gsm
) {
1914 spin_unlock(&gsm_mux_lock
);
1915 WARN_ON(i
== MAX_MUX
);
1917 del_timer_sync(&gsm
->t2_timer
);
1918 /* Now we are sure T2 has stopped */
1921 gsm_dlci_begin_close(dlci
);
1922 wait_event_interruptible(gsm
->event
,
1923 dlci
->state
== DLCI_CLOSED
);
1925 /* Free up any link layer users */
1926 for (i
= 0; i
< NUM_DLCI
; i
++)
1928 gsm_dlci_free(gsm
->dlci
[i
]);
1929 /* Now wipe the queues */
1930 for (txq
= gsm
->tx_head
; txq
!= NULL
; txq
= gsm
->tx_head
) {
1931 gsm
->tx_head
= txq
->next
;
1934 gsm
->tx_tail
= NULL
;
1936 EXPORT_SYMBOL_GPL(gsm_cleanup_mux
);
1939 * gsm_activate_mux - generic GSM setup
1942 * Set up the bits of the mux which are the same for all framing
1943 * protocols. Add the mux to the mux table so it can be opened and
1944 * finally kick off connecting to DLCI 0 on the modem.
1947 int gsm_activate_mux(struct gsm_mux
*gsm
)
1949 struct gsm_dlci
*dlci
;
1952 init_timer(&gsm
->t2_timer
);
1953 gsm
->t2_timer
.function
= gsm_control_retransmit
;
1954 gsm
->t2_timer
.data
= (unsigned long)gsm
;
1955 init_waitqueue_head(&gsm
->event
);
1956 spin_lock_init(&gsm
->control_lock
);
1957 spin_lock_init(&gsm
->tx_lock
);
1959 if (gsm
->encoding
== 0)
1960 gsm
->receive
= gsm0_receive
;
1962 gsm
->receive
= gsm1_receive
;
1963 gsm
->error
= gsm_error
;
1965 spin_lock(&gsm_mux_lock
);
1966 for (i
= 0; i
< MAX_MUX
; i
++) {
1967 if (gsm_mux
[i
] == NULL
) {
1972 spin_unlock(&gsm_mux_lock
);
1976 dlci
= gsm_dlci_alloc(gsm
, 0);
1979 gsm
->dead
= 0; /* Tty opens are now permissible */
1982 EXPORT_SYMBOL_GPL(gsm_activate_mux
);
1985 * gsm_free_mux - free up a mux
1988 * Dispose of allocated resources for a dead mux. No refcounting
1989 * at present so the mux must be truely dead.
1991 void gsm_free_mux(struct gsm_mux
*gsm
)
1993 kfree(gsm
->txframe
);
1997 EXPORT_SYMBOL_GPL(gsm_free_mux
);
2000 * gsm_alloc_mux - allocate a mux
2002 * Creates a new mux ready for activation.
2005 struct gsm_mux
*gsm_alloc_mux(void)
2007 struct gsm_mux
*gsm
= kzalloc(sizeof(struct gsm_mux
), GFP_KERNEL
);
2010 gsm
->buf
= kmalloc(MAX_MRU
+ 1, GFP_KERNEL
);
2011 if (gsm
->buf
== NULL
) {
2015 gsm
->txframe
= kmalloc(2 * MAX_MRU
+ 2, GFP_KERNEL
);
2016 if (gsm
->txframe
== NULL
) {
2021 spin_lock_init(&gsm
->lock
);
2030 gsm
->mru
= 64; /* Default to encoding 1 so these should be 64 */
2032 gsm
->dead
= 1; /* Avoid early tty opens */
2036 EXPORT_SYMBOL_GPL(gsm_alloc_mux
);
2042 * gsmld_output - write to link
2044 * @data: bytes to output
2047 * Write a block of data from the GSM mux to the data channel. This
2048 * will eventually be serialized from above but at the moment isn't.
2051 static int gsmld_output(struct gsm_mux
*gsm
, u8
*data
, int len
)
2053 if (tty_write_room(gsm
->tty
) < len
) {
2054 set_bit(TTY_DO_WRITE_WAKEUP
, &gsm
->tty
->flags
);
2058 printk("-->%d bytes out\n", len
);
2059 hex_packet(data
, len
);
2061 gsm
->tty
->ops
->write(gsm
->tty
, data
, len
);
2066 * gsmld_attach_gsm - mode set up
2067 * @tty: our tty structure
2070 * Set up the MUX for basic mode and commence connecting to the
2071 * modem. Currently called from the line discipline set up but
2072 * will need moving to an ioctl path.
2075 static int gsmld_attach_gsm(struct tty_struct
*tty
, struct gsm_mux
*gsm
)
2079 gsm
->tty
= tty_kref_get(tty
);
2080 gsm
->output
= gsmld_output
;
2081 ret
= gsm_activate_mux(gsm
);
2083 tty_kref_put(gsm
->tty
);
2089 * gsmld_detach_gsm - stop doing 0710 mux
2090 * @tty: tty atttached to the mux
2093 * Shutdown and then clean up the resources used by the line discipline
2096 static void gsmld_detach_gsm(struct tty_struct
*tty
, struct gsm_mux
*gsm
)
2098 WARN_ON(tty
!= gsm
->tty
);
2099 gsm_cleanup_mux(gsm
);
2100 tty_kref_put(gsm
->tty
);
2104 static void gsmld_receive_buf(struct tty_struct
*tty
, const unsigned char *cp
,
2105 char *fp
, int count
)
2107 struct gsm_mux
*gsm
= tty
->disc_data
;
2108 const unsigned char *dp
;
2115 printk("Inbytes %dd\n", count
);
2116 hex_packet(cp
, count
);
2119 for (i
= count
, dp
= cp
, f
= fp
; i
; i
--, dp
++) {
2123 gsm
->receive(gsm
, *dp
);
2129 gsm
->error(gsm
, *dp
, flags
);
2132 printk(KERN_ERR
"%s: unknown flag %d\n",
2133 tty_name(tty
, buf
), flags
);
2137 /* FASYNC if needed ? */
2138 /* If clogged call tty_throttle(tty); */
2142 * gsmld_chars_in_buffer - report available bytes
2145 * Report the number of characters buffered to be delivered to user
2146 * at this instant in time.
2151 static ssize_t
gsmld_chars_in_buffer(struct tty_struct
*tty
)
2157 * gsmld_flush_buffer - clean input queue
2158 * @tty: terminal device
2160 * Flush the input buffer. Called when the line discipline is
2161 * being closed, when the tty layer wants the buffer flushed (eg
2165 static void gsmld_flush_buffer(struct tty_struct
*tty
)
2170 * gsmld_close - close the ldisc for this tty
2173 * Called from the terminal layer when this line discipline is
2174 * being shut down, either because of a close or becsuse of a
2175 * discipline change. The function will not be called while other
2176 * ldisc methods are in progress.
2179 static void gsmld_close(struct tty_struct
*tty
)
2181 struct gsm_mux
*gsm
= tty
->disc_data
;
2183 gsmld_detach_gsm(tty
, gsm
);
2185 gsmld_flush_buffer(tty
);
2186 /* Do other clean up here */
2191 * gsmld_open - open an ldisc
2192 * @tty: terminal to open
2194 * Called when this line discipline is being attached to the
2195 * terminal device. Can sleep. Called serialized so that no
2196 * other events will occur in parallel. No further open will occur
2200 static int gsmld_open(struct tty_struct
*tty
)
2202 struct gsm_mux
*gsm
;
2204 if (tty
->ops
->write
== NULL
)
2207 /* Attach our ldisc data */
2208 gsm
= gsm_alloc_mux();
2212 tty
->disc_data
= gsm
;
2213 tty
->receive_room
= 65536;
2215 /* Attach the initial passive connection */
2217 return gsmld_attach_gsm(tty
, gsm
);
2221 * gsmld_write_wakeup - asynchronous I/O notifier
2224 * Required for the ptys, serial driver etc. since processes
2225 * that attach themselves to the master and rely on ASYNC
2226 * IO must be woken up
2229 static void gsmld_write_wakeup(struct tty_struct
*tty
)
2231 struct gsm_mux
*gsm
= tty
->disc_data
;
2232 unsigned long flags
;
2235 clear_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
2237 if (gsm
->tx_bytes
< TX_THRESH_LO
) {
2238 spin_lock_irqsave(&gsm
->tx_lock
, flags
);
2239 gsm_dlci_data_sweep(gsm
);
2240 spin_unlock_irqrestore(&gsm
->tx_lock
, flags
);
2245 * gsmld_read - read function for tty
2247 * @file: file object
2248 * @buf: userspace buffer pointer
2251 * Perform reads for the line discipline. We are guaranteed that the
2252 * line discipline will not be closed under us but we may get multiple
2253 * parallel readers and must handle this ourselves. We may also get
2254 * a hangup. Always called in user context, may sleep.
2256 * This code must be sure never to sleep through a hangup.
2259 static ssize_t
gsmld_read(struct tty_struct
*tty
, struct file
*file
,
2260 unsigned char __user
*buf
, size_t nr
)
2266 * gsmld_write - write function for tty
2268 * @file: file object
2269 * @buf: userspace buffer pointer
2272 * Called when the owner of the device wants to send a frame
2273 * itself (or some other control data). The data is transferred
2274 * as-is and must be properly framed and checksummed as appropriate
2275 * by userspace. Frames are either sent whole or not at all as this
2276 * avoids pain user side.
2279 static ssize_t
gsmld_write(struct tty_struct
*tty
, struct file
*file
,
2280 const unsigned char *buf
, size_t nr
)
2282 int space
= tty_write_room(tty
);
2284 return tty
->ops
->write(tty
, buf
, nr
);
2285 set_bit(TTY_DO_WRITE_WAKEUP
, &tty
->flags
);
2290 * gsmld_poll - poll method for N_GSM0710
2291 * @tty: terminal device
2292 * @file: file accessing it
2295 * Called when the line discipline is asked to poll() for data or
2296 * for special events. This code is not serialized with respect to
2297 * other events save open/close.
2299 * This code must be sure never to sleep through a hangup.
2300 * Called without the kernel lock held - fine
2303 static unsigned int gsmld_poll(struct tty_struct
*tty
, struct file
*file
,
2306 unsigned int mask
= 0;
2307 struct gsm_mux
*gsm
= tty
->disc_data
;
2309 poll_wait(file
, &tty
->read_wait
, wait
);
2310 poll_wait(file
, &tty
->write_wait
, wait
);
2311 if (tty_hung_up_p(file
))
2313 if (!tty_is_writelocked(tty
) && tty_write_room(tty
) > 0)
2314 mask
|= POLLOUT
| POLLWRNORM
;
2320 static int gsmld_config(struct tty_struct
*tty
, struct gsm_mux
*gsm
,
2321 struct gsm_config
*c
)
2324 int need_restart
= 0;
2326 /* Stuff we don't support yet - UI or I frame transport, windowing */
2327 if ((c
->adaption
!=1 && c
->adaption
!= 2) || c
->k
)
2329 /* Check the MRU/MTU range looks sane */
2330 if (c
->mru
> MAX_MRU
|| c
->mtu
> MAX_MTU
|| c
->mru
< 8 || c
->mtu
< 8)
2334 if (c
->encapsulation
> 1) /* Basic, advanced, no I */
2336 if (c
->initiator
> 1)
2338 if (c
->i
== 0 || c
->i
> 2) /* UIH and UI only */
2341 * See what is needed for reconfiguration
2345 if (c
->t1
!= 0 && c
->t1
!= gsm
->t1
)
2347 if (c
->t2
!= 0 && c
->t2
!= gsm
->t2
)
2349 if (c
->encapsulation
!= gsm
->encoding
)
2351 if (c
->adaption
!= gsm
->adaption
)
2354 if (c
->initiator
!= gsm
->initiator
)
2356 if (c
->mru
!= gsm
->mru
)
2358 if (c
->mtu
!= gsm
->mtu
)
2362 * Close down what is needed, restart and initiate the new
2366 if (need_close
|| need_restart
) {
2367 gsm_dlci_begin_close(gsm
->dlci
[0]);
2368 /* This will timeout if the link is down due to N2 expiring */
2369 wait_event_interruptible(gsm
->event
,
2370 gsm
->dlci
[0]->state
== DLCI_CLOSED
);
2371 if (signal_pending(current
))
2375 gsm_cleanup_mux(gsm
);
2377 gsm
->initiator
= c
->initiator
;
2379 gsm
->encoding
= c
->encapsulation
;
2380 gsm
->adaption
= c
->adaption
;
2392 /* FIXME: We need to separate activation/deactivation from adding
2393 and removing from the mux array */
2395 gsm_activate_mux(gsm
);
2396 if (gsm
->initiator
&& need_close
)
2397 gsm_dlci_begin_open(gsm
->dlci
[0]);
2401 static int gsmld_ioctl(struct tty_struct
*tty
, struct file
*file
,
2402 unsigned int cmd
, unsigned long arg
)
2404 struct gsm_config c
;
2405 struct gsm_mux
*gsm
= tty
->disc_data
;
2408 case GSMIOC_GETCONF
:
2409 memset(&c
, 0, sizeof(c
));
2410 c
.adaption
= gsm
->adaption
;
2411 c
.encapsulation
= gsm
->encoding
;
2412 c
.initiator
= gsm
->initiator
;
2415 c
.t3
= 0; /* Not supported */
2417 if (gsm
->ftype
== UIH
)
2421 printk("Ftype %d i %d\n", gsm
->ftype
, c
.i
);
2425 if (copy_to_user((void *)arg
, &c
, sizeof(c
)))
2428 case GSMIOC_SETCONF
:
2429 if (copy_from_user(&c
, (void *)arg
, sizeof(c
)))
2431 return gsmld_config(tty
, gsm
, &c
);
2433 return n_tty_ioctl_helper(tty
, file
, cmd
, arg
);
2438 /* Line discipline for real tty */
2439 struct tty_ldisc_ops tty_ldisc_packet
= {
2440 .owner
= THIS_MODULE
,
2441 .magic
= TTY_LDISC_MAGIC
,
2444 .close
= gsmld_close
,
2445 .flush_buffer
= gsmld_flush_buffer
,
2446 .chars_in_buffer
= gsmld_chars_in_buffer
,
2448 .write
= gsmld_write
,
2449 .ioctl
= gsmld_ioctl
,
2451 .receive_buf
= gsmld_receive_buf
,
2452 .write_wakeup
= gsmld_write_wakeup
2461 static int gsmtty_modem_update(struct gsm_dlci
*dlci
, u8 brk
)
2464 struct gsm_control
*ctrl
;
2470 modembits
[0] = len
<< 1 | EA
; /* Data bytes */
2471 modembits
[1] = dlci
->addr
<< 2 | 3; /* DLCI, EA, 1 */
2472 modembits
[2] = gsm_encode_modem(dlci
) << 1 | EA
;
2474 modembits
[3] = brk
<< 4 | 2 | EA
; /* Valid, EA */
2475 ctrl
= gsm_control_send(dlci
->gsm
, CMD_MSC
, modembits
, len
+ 1);
2478 return gsm_control_wait(dlci
->gsm
, ctrl
);
2481 static int gsm_carrier_raised(struct tty_port
*port
)
2483 struct gsm_dlci
*dlci
= container_of(port
, struct gsm_dlci
, port
);
2484 /* Not yet open so no carrier info */
2485 if (dlci
->state
!= DLCI_OPEN
)
2489 return dlci
->modem_rx
& TIOCM_CD
;
2492 static void gsm_dtr_rts(struct tty_port
*port
, int onoff
)
2494 struct gsm_dlci
*dlci
= container_of(port
, struct gsm_dlci
, port
);
2495 unsigned int modem_tx
= dlci
->modem_tx
;
2497 modem_tx
|= TIOCM_DTR
| TIOCM_RTS
;
2499 modem_tx
&= ~(TIOCM_DTR
| TIOCM_RTS
);
2500 if (modem_tx
!= dlci
->modem_tx
) {
2501 dlci
->modem_tx
= modem_tx
;
2502 gsmtty_modem_update(dlci
, 0);
2506 static const struct tty_port_operations gsm_port_ops
= {
2507 .carrier_raised
= gsm_carrier_raised
,
2508 .dtr_rts
= gsm_dtr_rts
,
2512 static int gsmtty_open(struct tty_struct
*tty
, struct file
*filp
)
2514 struct gsm_mux
*gsm
;
2515 struct gsm_dlci
*dlci
;
2516 struct tty_port
*port
;
2517 unsigned int line
= tty
->index
;
2518 unsigned int mux
= line
>> 6;
2524 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2525 if (gsm_mux
[mux
] == NULL
)
2527 if (line
== 0 || line
> 61) /* 62/63 reserved */
2532 dlci
= gsm
->dlci
[line
];
2534 dlci
= gsm_dlci_alloc(gsm
, line
);
2539 tty
->driver_data
= dlci
;
2540 tty_port_tty_set(port
, tty
);
2543 /* We could in theory open and close before we wait - eg if we get
2544 a DM straight back. This is ok as that will have caused a hangup */
2545 set_bit(ASYNCB_INITIALIZED
, &port
->flags
);
2546 /* Start sending off SABM messages */
2547 gsm_dlci_begin_open(dlci
);
2548 /* And wait for virtual carrier */
2549 return tty_port_block_til_ready(port
, tty
, filp
);
2552 static void gsmtty_close(struct tty_struct
*tty
, struct file
*filp
)
2554 struct gsm_dlci
*dlci
= tty
->driver_data
;
2557 if (tty_port_close_start(&dlci
->port
, tty
, filp
) == 0)
2559 gsm_dlci_begin_close(dlci
);
2560 tty_port_close_end(&dlci
->port
, tty
);
2561 tty_port_tty_set(&dlci
->port
, NULL
);
2564 static void gsmtty_hangup(struct tty_struct
*tty
)
2566 struct gsm_dlci
*dlci
= tty
->driver_data
;
2567 tty_port_hangup(&dlci
->port
);
2568 gsm_dlci_begin_close(dlci
);
2571 static int gsmtty_write(struct tty_struct
*tty
, const unsigned char *buf
,
2574 struct gsm_dlci
*dlci
= tty
->driver_data
;
2575 /* Stuff the bytes into the fifo queue */
2576 int sent
= kfifo_in_locked(dlci
->fifo
, buf
, len
, &dlci
->lock
);
2577 /* Need to kick the channel */
2578 gsm_dlci_data_kick(dlci
);
2582 static int gsmtty_write_room(struct tty_struct
*tty
)
2584 struct gsm_dlci
*dlci
= tty
->driver_data
;
2585 return TX_SIZE
- kfifo_len(dlci
->fifo
);
2588 static int gsmtty_chars_in_buffer(struct tty_struct
*tty
)
2590 struct gsm_dlci
*dlci
= tty
->driver_data
;
2591 return kfifo_len(dlci
->fifo
);
2594 static void gsmtty_flush_buffer(struct tty_struct
*tty
)
2596 struct gsm_dlci
*dlci
= tty
->driver_data
;
2597 /* Caution needed: If we implement reliable transport classes
2598 then the data being transmitted can't simply be junked once
2599 it has first hit the stack. Until then we can just blow it
2601 kfifo_reset(dlci
->fifo
);
2602 /* Need to unhook this DLCI from the transmit queue logic */
2605 static void gsmtty_wait_until_sent(struct tty_struct
*tty
, int timeout
)
2607 /* The FIFO handles the queue so the kernel will do the right
2608 thing waiting on chars_in_buffer before calling us. No work
2612 static int gsmtty_tiocmget(struct tty_struct
*tty
, struct file
*filp
)
2614 struct gsm_dlci
*dlci
= tty
->driver_data
;
2615 return dlci
->modem_rx
;
2618 static int gsmtty_tiocmset(struct tty_struct
*tty
, struct file
*filp
,
2619 unsigned int set
, unsigned int clear
)
2621 struct gsm_dlci
*dlci
= tty
->driver_data
;
2622 unsigned int modem_tx
= dlci
->modem_tx
;
2627 if (modem_tx
!= dlci
->modem_tx
) {
2628 dlci
->modem_tx
= modem_tx
;
2629 return gsmtty_modem_update(dlci
, 0);
2635 static int gsmtty_ioctl(struct tty_struct
*tty
, struct file
*filp
,
2636 unsigned int cmd
, unsigned long arg
)
2638 return -ENOIOCTLCMD
;
2641 static void gsmtty_set_termios(struct tty_struct
*tty
, struct ktermios
*old
)
2643 /* For the moment its fixed. In actual fact the speed information
2644 for the virtual channel can be propogated in both directions by
2645 the RPN control message. This however rapidly gets nasty as we
2646 then have to remap modem signals each way according to whether
2647 our virtual cable is null modem etc .. */
2648 tty_termios_copy_hw(tty
->termios
, old
);
2651 static void gsmtty_throttle(struct tty_struct
*tty
)
2653 struct gsm_dlci
*dlci
= tty
->driver_data
;
2654 if (tty
->termios
->c_cflag
& CRTSCTS
)
2655 dlci
->modem_tx
&= ~TIOCM_DTR
;
2656 dlci
->throttled
= 1;
2657 /* Send an MSC with DTR cleared */
2658 gsmtty_modem_update(dlci
, 0);
2661 static void gsmtty_unthrottle(struct tty_struct
*tty
)
2663 struct gsm_dlci
*dlci
= tty
->driver_data
;
2664 if (tty
->termios
->c_cflag
& CRTSCTS
)
2665 dlci
->modem_tx
|= TIOCM_DTR
;
2666 dlci
->throttled
= 0;
2667 /* Send an MSC with DTR set */
2668 gsmtty_modem_update(dlci
, 0);
2671 static int gsmtty_break_ctl(struct tty_struct
*tty
, int state
)
2673 struct gsm_dlci
*dlci
= tty
->driver_data
;
2674 int encode
= 0; /* Off */
2676 if (state
== -1) /* "On indefinitely" - we can't encode this
2679 else if (state
> 0) {
2680 encode
= state
/ 200; /* mS to encoding */
2682 encode
= 0x0F; /* Best effort */
2684 return gsmtty_modem_update(dlci
, encode
);
2687 static struct tty_driver
*gsm_tty_driver
;
2689 /* Virtual ttys for the demux */
2690 static const struct tty_operations gsmtty_ops
= {
2691 .open
= gsmtty_open
,
2692 .close
= gsmtty_close
,
2693 .write
= gsmtty_write
,
2694 .write_room
= gsmtty_write_room
,
2695 .chars_in_buffer
= gsmtty_chars_in_buffer
,
2696 .flush_buffer
= gsmtty_flush_buffer
,
2697 .ioctl
= gsmtty_ioctl
,
2698 .throttle
= gsmtty_throttle
,
2699 .unthrottle
= gsmtty_unthrottle
,
2700 .set_termios
= gsmtty_set_termios
,
2701 .hangup
= gsmtty_hangup
,
2702 .wait_until_sent
= gsmtty_wait_until_sent
,
2703 .tiocmget
= gsmtty_tiocmget
,
2704 .tiocmset
= gsmtty_tiocmset
,
2705 .break_ctl
= gsmtty_break_ctl
,
2710 static int __init
gsm_init(void)
2712 /* Fill in our line protocol discipline, and register it */
2713 int status
= tty_register_ldisc(N_GSM0710
, &tty_ldisc_packet
);
2715 printk(KERN_ERR
"n_gsm: can't register line discipline (err = %d)\n", status
);
2719 gsm_tty_driver
= alloc_tty_driver(256);
2720 if (!gsm_tty_driver
) {
2721 tty_unregister_ldisc(N_GSM0710
);
2722 printk(KERN_ERR
"gsm_init: tty allocation failed.\n");
2725 gsm_tty_driver
->owner
= THIS_MODULE
;
2726 gsm_tty_driver
->driver_name
= "gsmtty";
2727 gsm_tty_driver
->name
= "gsmtty";
2728 gsm_tty_driver
->major
= 0; /* Dynamic */
2729 gsm_tty_driver
->minor_start
= 0;
2730 gsm_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
2731 gsm_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
2732 gsm_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
2733 | TTY_DRIVER_HARDWARE_BREAK
;
2734 gsm_tty_driver
->init_termios
= tty_std_termios
;
2736 gsm_tty_driver
->init_termios
.c_lflag
&= ~ECHO
;
2737 tty_set_operations(gsm_tty_driver
, &gsmtty_ops
);
2739 spin_lock_init(&gsm_mux_lock
);
2741 if (tty_register_driver(gsm_tty_driver
)) {
2742 put_tty_driver(gsm_tty_driver
);
2743 tty_unregister_ldisc(N_GSM0710
);
2744 printk(KERN_ERR
"gsm_init: tty registration failed.\n");
2747 printk(KERN_INFO
"gsm_init: loaded as %d,%d.\n", gsm_tty_driver
->major
, gsm_tty_driver
->minor_start
);
2751 static void __exit
gsm_exit(void)
2753 int status
= tty_unregister_ldisc(N_GSM0710
);
2755 printk(KERN_ERR
"n_gsm: can't unregister line discipline (err = %d)\n", status
);
2756 tty_unregister_driver(gsm_tty_driver
);
2757 put_tty_driver(gsm_tty_driver
);
2758 printk(KERN_INFO
"gsm_init: unloaded.\n");
2761 module_init(gsm_init
);
2762 module_exit(gsm_exit
);
2765 MODULE_LICENSE("GPL");
2766 MODULE_ALIAS_LDISC(N_GSM0710
);