aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/tty/n_gsm.c
diff options
context:
space:
mode:
authorGlenn Elliott <gelliott@cs.unc.edu>2012-03-04 19:47:13 -0500
committerGlenn Elliott <gelliott@cs.unc.edu>2012-03-04 19:47:13 -0500
commitc71c03bda1e86c9d5198c5d83f712e695c4f2a1e (patch)
treeecb166cb3e2b7e2adb3b5e292245fefd23381ac8 /drivers/tty/n_gsm.c
parentea53c912f8a86a8567697115b6a0d8152beee5c8 (diff)
parent6a00f206debf8a5c8899055726ad127dbeeed098 (diff)
Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp
Conflicts: litmus/sched_cedf.c
Diffstat (limited to 'drivers/tty/n_gsm.c')
-rw-r--r--drivers/tty/n_gsm.c2810
1 files changed, 2810 insertions, 0 deletions
diff --git a/drivers/tty/n_gsm.c b/drivers/tty/n_gsm.c
new file mode 100644
index 000000000000..19b4ae052af8
--- /dev/null
+++ b/drivers/tty/n_gsm.c
@@ -0,0 +1,2810 @@
1/*
2 * n_gsm.c GSM 0710 tty multiplexor
3 * Copyright (c) 2009/10 Intel Corporation
4 *
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.
8 *
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.
13 *
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.
17 *
18 * * THIS IS A DEVELOPMENT SNAPSHOT IT IS NOT A FINAL RELEASE *
19 *
20 * TO DO:
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 * Test basic encoding
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
35 *
36 */
37
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/ctype.h>
47#include <linux/mm.h>
48#include <linux/string.h>
49#include <linux/slab.h>
50#include <linux/poll.h>
51#include <linux/bitops.h>
52#include <linux/file.h>
53#include <linux/uaccess.h>
54#include <linux/module.h>
55#include <linux/timer.h>
56#include <linux/tty_flip.h>
57#include <linux/tty_driver.h>
58#include <linux/serial.h>
59#include <linux/kfifo.h>
60#include <linux/skbuff.h>
61#include <linux/gsmmux.h>
62
63static int debug;
64module_param(debug, int, 0600);
65
66#define T1 (HZ/10)
67#define T2 (HZ/3)
68#define N2 3
69
70/* Use long timers for testing at low speed with debug on */
71#ifdef DEBUG_TIMING
72#define T1 HZ
73#define T2 (2 * HZ)
74#endif
75
76/*
77 * Semi-arbitrary buffer size limits. 0710 is normally run with 32-64 byte
78 * limits so this is plenty
79 */
80#define MAX_MRU 512
81#define MAX_MTU 512
82
83/*
84 * Each block of data we have queued to go out is in the form of
85 * a gsm_msg which holds everything we need in a link layer independent
86 * format
87 */
88
89struct gsm_msg {
90 struct gsm_msg *next;
91 u8 addr; /* DLCI address + flags */
92 u8 ctrl; /* Control byte + flags */
93 unsigned int len; /* Length of data block (can be zero) */
94 unsigned char *data; /* Points into buffer but not at the start */
95 unsigned char buffer[0];
96};
97
98/*
99 * Each active data link has a gsm_dlci structure associated which ties
100 * the link layer to an optional tty (if the tty side is open). To avoid
101 * complexity right now these are only ever freed up when the mux is
102 * shut down.
103 *
104 * At the moment we don't free DLCI objects until the mux is torn down
105 * this avoid object life time issues but might be worth review later.
106 */
107
108struct gsm_dlci {
109 struct gsm_mux *gsm;
110 int addr;
111 int state;
112#define DLCI_CLOSED 0
113#define DLCI_OPENING 1 /* Sending SABM not seen UA */
114#define DLCI_OPEN 2 /* SABM/UA complete */
115#define DLCI_CLOSING 3 /* Sending DISC not seen UA/DM */
116
117 /* Link layer */
118 spinlock_t lock; /* Protects the internal state */
119 struct timer_list t1; /* Retransmit timer for SABM and UA */
120 int retries;
121 /* Uplink tty if active */
122 struct tty_port port; /* The tty bound to this DLCI if there is one */
123 struct kfifo *fifo; /* Queue fifo for the DLCI */
124 struct kfifo _fifo; /* For new fifo API porting only */
125 int adaption; /* Adaption layer in use */
126 u32 modem_rx; /* Our incoming virtual modem lines */
127 u32 modem_tx; /* Our outgoing modem lines */
128 int dead; /* Refuse re-open */
129 /* Flow control */
130 int throttled; /* Private copy of throttle state */
131 int constipated; /* Throttle status for outgoing */
132 /* Packetised I/O */
133 struct sk_buff *skb; /* Frame being sent */
134 struct sk_buff_head skb_list; /* Queued frames */
135 /* Data handling callback */
136 void (*data)(struct gsm_dlci *dlci, u8 *data, int len);
137};
138
139/* DLCI 0, 62/63 are special or reseved see gsmtty_open */
140
141#define NUM_DLCI 64
142
143/*
144 * DLCI 0 is used to pass control blocks out of band of the data
145 * flow (and with a higher link priority). One command can be outstanding
146 * at a time and we use this structure to manage them. They are created
147 * and destroyed by the user context, and updated by the receive paths
148 * and timers
149 */
150
151struct gsm_control {
152 u8 cmd; /* Command we are issuing */
153 u8 *data; /* Data for the command in case we retransmit */
154 int len; /* Length of block for retransmission */
155 int done; /* Done flag */
156 int error; /* Error if any */
157};
158
159/*
160 * Each GSM mux we have is represented by this structure. If we are
161 * operating as an ldisc then we use this structure as our ldisc
162 * state. We need to sort out lifetimes and locking with respect
163 * to the gsm mux array. For now we don't free DLCI objects that
164 * have been instantiated until the mux itself is terminated.
165 *
166 * To consider further: tty open versus mux shutdown.
167 */
168
169struct gsm_mux {
170 struct tty_struct *tty; /* The tty our ldisc is bound to */
171 spinlock_t lock;
172
173 /* Events on the GSM channel */
174 wait_queue_head_t event;
175
176 /* Bits for GSM mode decoding */
177
178 /* Framing Layer */
179 unsigned char *buf;
180 int state;
181#define GSM_SEARCH 0
182#define GSM_START 1
183#define GSM_ADDRESS 2
184#define GSM_CONTROL 3
185#define GSM_LEN 4
186#define GSM_DATA 5
187#define GSM_FCS 6
188#define GSM_OVERRUN 7
189#define GSM_LEN0 8
190#define GSM_LEN1 9
191#define GSM_SSOF 10
192 unsigned int len;
193 unsigned int address;
194 unsigned int count;
195 int escape;
196 int encoding;
197 u8 control;
198 u8 fcs;
199 u8 received_fcs;
200 u8 *txframe; /* TX framing buffer */
201
202 /* Methods for the receiver side */
203 void (*receive)(struct gsm_mux *gsm, u8 ch);
204 void (*error)(struct gsm_mux *gsm, u8 ch, u8 flag);
205 /* And transmit side */
206 int (*output)(struct gsm_mux *mux, u8 *data, int len);
207
208 /* Link Layer */
209 unsigned int mru;
210 unsigned int mtu;
211 int initiator; /* Did we initiate connection */
212 int dead; /* Has the mux been shut down */
213 struct gsm_dlci *dlci[NUM_DLCI];
214 int constipated; /* Asked by remote to shut up */
215
216 spinlock_t tx_lock;
217 unsigned int tx_bytes; /* TX data outstanding */
218#define TX_THRESH_HI 8192
219#define TX_THRESH_LO 2048
220 struct gsm_msg *tx_head; /* Pending data packets */
221 struct gsm_msg *tx_tail;
222
223 /* Control messages */
224 struct timer_list t2_timer; /* Retransmit timer for commands */
225 int cretries; /* Command retry counter */
226 struct gsm_control *pending_cmd;/* Our current pending command */
227 spinlock_t control_lock; /* Protects the pending command */
228
229 /* Configuration */
230 int adaption; /* 1 or 2 supported */
231 u8 ftype; /* UI or UIH */
232 int t1, t2; /* Timers in 1/100th of a sec */
233 int n2; /* Retry count */
234
235 /* Statistics (not currently exposed) */
236 unsigned long bad_fcs;
237 unsigned long malformed;
238 unsigned long io_error;
239 unsigned long bad_size;
240 unsigned long unsupported;
241};
242
243
244/*
245 * Mux objects - needed so that we can translate a tty index into the
246 * relevant mux and DLCI.
247 */
248
249#define MAX_MUX 4 /* 256 minors */
250static struct gsm_mux *gsm_mux[MAX_MUX]; /* GSM muxes */
251static spinlock_t gsm_mux_lock;
252
253/*
254 * This section of the driver logic implements the GSM encodings
255 * both the basic and the 'advanced'. Reliable transport is not
256 * supported.
257 */
258
259#define CR 0x02
260#define EA 0x01
261#define PF 0x10
262
263/* I is special: the rest are ..*/
264#define RR 0x01
265#define UI 0x03
266#define RNR 0x05
267#define REJ 0x09
268#define DM 0x0F
269#define SABM 0x2F
270#define DISC 0x43
271#define UA 0x63
272#define UIH 0xEF
273
274/* Channel commands */
275#define CMD_NSC 0x09
276#define CMD_TEST 0x11
277#define CMD_PSC 0x21
278#define CMD_RLS 0x29
279#define CMD_FCOFF 0x31
280#define CMD_PN 0x41
281#define CMD_RPN 0x49
282#define CMD_FCON 0x51
283#define CMD_CLD 0x61
284#define CMD_SNC 0x69
285#define CMD_MSC 0x71
286
287/* Virtual modem bits */
288#define MDM_FC 0x01
289#define MDM_RTC 0x02
290#define MDM_RTR 0x04
291#define MDM_IC 0x20
292#define MDM_DV 0x40
293
294#define GSM0_SOF 0xF9
295#define GSM1_SOF 0x7E
296#define GSM1_ESCAPE 0x7D
297#define GSM1_ESCAPE_BITS 0x20
298#define XON 0x11
299#define XOFF 0x13
300
301static const struct tty_port_operations gsm_port_ops;
302
303/*
304 * CRC table for GSM 0710
305 */
306
307static const u8 gsm_fcs8[256] = {
308 0x00, 0x91, 0xE3, 0x72, 0x07, 0x96, 0xE4, 0x75,
309 0x0E, 0x9F, 0xED, 0x7C, 0x09, 0x98, 0xEA, 0x7B,
310 0x1C, 0x8D, 0xFF, 0x6E, 0x1B, 0x8A, 0xF8, 0x69,
311 0x12, 0x83, 0xF1, 0x60, 0x15, 0x84, 0xF6, 0x67,
312 0x38, 0xA9, 0xDB, 0x4A, 0x3F, 0xAE, 0xDC, 0x4D,
313 0x36, 0xA7, 0xD5, 0x44, 0x31, 0xA0, 0xD2, 0x43,
314 0x24, 0xB5, 0xC7, 0x56, 0x23, 0xB2, 0xC0, 0x51,
315 0x2A, 0xBB, 0xC9, 0x58, 0x2D, 0xBC, 0xCE, 0x5F,
316 0x70, 0xE1, 0x93, 0x02, 0x77, 0xE6, 0x94, 0x05,
317 0x7E, 0xEF, 0x9D, 0x0C, 0x79, 0xE8, 0x9A, 0x0B,
318 0x6C, 0xFD, 0x8F, 0x1E, 0x6B, 0xFA, 0x88, 0x19,
319 0x62, 0xF3, 0x81, 0x10, 0x65, 0xF4, 0x86, 0x17,
320 0x48, 0xD9, 0xAB, 0x3A, 0x4F, 0xDE, 0xAC, 0x3D,
321 0x46, 0xD7, 0xA5, 0x34, 0x41, 0xD0, 0xA2, 0x33,
322 0x54, 0xC5, 0xB7, 0x26, 0x53, 0xC2, 0xB0, 0x21,
323 0x5A, 0xCB, 0xB9, 0x28, 0x5D, 0xCC, 0xBE, 0x2F,
324 0xE0, 0x71, 0x03, 0x92, 0xE7, 0x76, 0x04, 0x95,
325 0xEE, 0x7F, 0x0D, 0x9C, 0xE9, 0x78, 0x0A, 0x9B,
326 0xFC, 0x6D, 0x1F, 0x8E, 0xFB, 0x6A, 0x18, 0x89,
327 0xF2, 0x63, 0x11, 0x80, 0xF5, 0x64, 0x16, 0x87,
328 0xD8, 0x49, 0x3B, 0xAA, 0xDF, 0x4E, 0x3C, 0xAD,
329 0xD6, 0x47, 0x35, 0xA4, 0xD1, 0x40, 0x32, 0xA3,
330 0xC4, 0x55, 0x27, 0xB6, 0xC3, 0x52, 0x20, 0xB1,
331 0xCA, 0x5B, 0x29, 0xB8, 0xCD, 0x5C, 0x2E, 0xBF,
332 0x90, 0x01, 0x73, 0xE2, 0x97, 0x06, 0x74, 0xE5,
333 0x9E, 0x0F, 0x7D, 0xEC, 0x99, 0x08, 0x7A, 0xEB,
334 0x8C, 0x1D, 0x6F, 0xFE, 0x8B, 0x1A, 0x68, 0xF9,
335 0x82, 0x13, 0x61, 0xF0, 0x85, 0x14, 0x66, 0xF7,
336 0xA8, 0x39, 0x4B, 0xDA, 0xAF, 0x3E, 0x4C, 0xDD,
337 0xA6, 0x37, 0x45, 0xD4, 0xA1, 0x30, 0x42, 0xD3,
338 0xB4, 0x25, 0x57, 0xC6, 0xB3, 0x22, 0x50, 0xC1,
339 0xBA, 0x2B, 0x59, 0xC8, 0xBD, 0x2C, 0x5E, 0xCF
340};
341
342#define INIT_FCS 0xFF
343#define GOOD_FCS 0xCF
344
345/**
346 * gsm_fcs_add - update FCS
347 * @fcs: Current FCS
348 * @c: Next data
349 *
350 * Update the FCS to include c. Uses the algorithm in the specification
351 * notes.
352 */
353
354static inline u8 gsm_fcs_add(u8 fcs, u8 c)
355{
356 return gsm_fcs8[fcs ^ c];
357}
358
359/**
360 * gsm_fcs_add_block - update FCS for a block
361 * @fcs: Current FCS
362 * @c: buffer of data
363 * @len: length of buffer
364 *
365 * Update the FCS to include c. Uses the algorithm in the specification
366 * notes.
367 */
368
369static inline u8 gsm_fcs_add_block(u8 fcs, u8 *c, int len)
370{
371 while (len--)
372 fcs = gsm_fcs8[fcs ^ *c++];
373 return fcs;
374}
375
376/**
377 * gsm_read_ea - read a byte into an EA
378 * @val: variable holding value
379 * c: byte going into the EA
380 *
381 * Processes one byte of an EA. Updates the passed variable
382 * and returns 1 if the EA is now completely read
383 */
384
385static int gsm_read_ea(unsigned int *val, u8 c)
386{
387 /* Add the next 7 bits into the value */
388 *val <<= 7;
389 *val |= c >> 1;
390 /* Was this the last byte of the EA 1 = yes*/
391 return c & EA;
392}
393
394/**
395 * gsm_encode_modem - encode modem data bits
396 * @dlci: DLCI to encode from
397 *
398 * Returns the correct GSM encoded modem status bits (6 bit field) for
399 * the current status of the DLCI and attached tty object
400 */
401
402static u8 gsm_encode_modem(const struct gsm_dlci *dlci)
403{
404 u8 modembits = 0;
405 /* FC is true flow control not modem bits */
406 if (dlci->throttled)
407 modembits |= MDM_FC;
408 if (dlci->modem_tx & TIOCM_DTR)
409 modembits |= MDM_RTC;
410 if (dlci->modem_tx & TIOCM_RTS)
411 modembits |= MDM_RTR;
412 if (dlci->modem_tx & TIOCM_RI)
413 modembits |= MDM_IC;
414 if (dlci->modem_tx & TIOCM_CD)
415 modembits |= MDM_DV;
416 return modembits;
417}
418
419/**
420 * gsm_print_packet - display a frame for debug
421 * @hdr: header to print before decode
422 * @addr: address EA from the frame
423 * @cr: C/R bit from the frame
424 * @control: control including PF bit
425 * @data: following data bytes
426 * @dlen: length of data
427 *
428 * Displays a packet in human readable format for debugging purposes. The
429 * style is based on amateur radio LAP-B dump display.
430 */
431
432static void gsm_print_packet(const char *hdr, int addr, int cr,
433 u8 control, const u8 *data, int dlen)
434{
435 if (!(debug & 1))
436 return;
437
438 pr_info("%s %d) %c: ", hdr, addr, "RC"[cr]);
439
440 switch (control & ~PF) {
441 case SABM:
442 pr_cont("SABM");
443 break;
444 case UA:
445 pr_cont("UA");
446 break;
447 case DISC:
448 pr_cont("DISC");
449 break;
450 case DM:
451 pr_cont("DM");
452 break;
453 case UI:
454 pr_cont("UI");
455 break;
456 case UIH:
457 pr_cont("UIH");
458 break;
459 default:
460 if (!(control & 0x01)) {
461 pr_cont("I N(S)%d N(R)%d",
462 (control & 0x0E) >> 1, (control & 0xE) >> 5);
463 } else switch (control & 0x0F) {
464 case RR:
465 pr_cont("RR(%d)", (control & 0xE0) >> 5);
466 break;
467 case RNR:
468 pr_cont("RNR(%d)", (control & 0xE0) >> 5);
469 break;
470 case REJ:
471 pr_cont("REJ(%d)", (control & 0xE0) >> 5);
472 break;
473 default:
474 pr_cont("[%02X]", control);
475 }
476 }
477
478 if (control & PF)
479 pr_cont("(P)");
480 else
481 pr_cont("(F)");
482
483 if (dlen) {
484 int ct = 0;
485 while (dlen--) {
486 if (ct % 8 == 0) {
487 pr_cont("\n");
488 pr_debug(" ");
489 }
490 pr_cont("%02X ", *data++);
491 ct++;
492 }
493 }
494 pr_cont("\n");
495}
496
497
498/*
499 * Link level transmission side
500 */
501
502/**
503 * gsm_stuff_packet - bytestuff a packet
504 * @ibuf: input
505 * @obuf: output
506 * @len: length of input
507 *
508 * Expand a buffer by bytestuffing it. The worst case size change
509 * is doubling and the caller is responsible for handing out
510 * suitable sized buffers.
511 */
512
513static int gsm_stuff_frame(const u8 *input, u8 *output, int len)
514{
515 int olen = 0;
516 while (len--) {
517 if (*input == GSM1_SOF || *input == GSM1_ESCAPE
518 || *input == XON || *input == XOFF) {
519 *output++ = GSM1_ESCAPE;
520 *output++ = *input++ ^ GSM1_ESCAPE_BITS;
521 olen++;
522 } else
523 *output++ = *input++;
524 olen++;
525 }
526 return olen;
527}
528
529/**
530 * gsm_send - send a control frame
531 * @gsm: our GSM mux
532 * @addr: address for control frame
533 * @cr: command/response bit
534 * @control: control byte including PF bit
535 *
536 * Format up and transmit a control frame. These do not go via the
537 * queueing logic as they should be transmitted ahead of data when
538 * they are needed.
539 *
540 * FIXME: Lock versus data TX path
541 */
542
543static void gsm_send(struct gsm_mux *gsm, int addr, int cr, int control)
544{
545 int len;
546 u8 cbuf[10];
547 u8 ibuf[3];
548
549 switch (gsm->encoding) {
550 case 0:
551 cbuf[0] = GSM0_SOF;
552 cbuf[1] = (addr << 2) | (cr << 1) | EA;
553 cbuf[2] = control;
554 cbuf[3] = EA; /* Length of data = 0 */
555 cbuf[4] = 0xFF - gsm_fcs_add_block(INIT_FCS, cbuf + 1, 3);
556 cbuf[5] = GSM0_SOF;
557 len = 6;
558 break;
559 case 1:
560 case 2:
561 /* Control frame + packing (but not frame stuffing) in mode 1 */
562 ibuf[0] = (addr << 2) | (cr << 1) | EA;
563 ibuf[1] = control;
564 ibuf[2] = 0xFF - gsm_fcs_add_block(INIT_FCS, ibuf, 2);
565 /* Stuffing may double the size worst case */
566 len = gsm_stuff_frame(ibuf, cbuf + 1, 3);
567 /* Now add the SOF markers */
568 cbuf[0] = GSM1_SOF;
569 cbuf[len + 1] = GSM1_SOF;
570 /* FIXME: we can omit the lead one in many cases */
571 len += 2;
572 break;
573 default:
574 WARN_ON(1);
575 return;
576 }
577 gsm->output(gsm, cbuf, len);
578 gsm_print_packet("-->", addr, cr, control, NULL, 0);
579}
580
581/**
582 * gsm_response - send a control response
583 * @gsm: our GSM mux
584 * @addr: address for control frame
585 * @control: control byte including PF bit
586 *
587 * Format up and transmit a link level response frame.
588 */
589
590static inline void gsm_response(struct gsm_mux *gsm, int addr, int control)
591{
592 gsm_send(gsm, addr, 0, control);
593}
594
595/**
596 * gsm_command - send a control command
597 * @gsm: our GSM mux
598 * @addr: address for control frame
599 * @control: control byte including PF bit
600 *
601 * Format up and transmit a link level command frame.
602 */
603
604static inline void gsm_command(struct gsm_mux *gsm, int addr, int control)
605{
606 gsm_send(gsm, addr, 1, control);
607}
608
609/* Data transmission */
610
611#define HDR_LEN 6 /* ADDR CTRL [LEN.2] DATA FCS */
612
613/**
614 * gsm_data_alloc - allocate data frame
615 * @gsm: GSM mux
616 * @addr: DLCI address
617 * @len: length excluding header and FCS
618 * @ctrl: control byte
619 *
620 * Allocate a new data buffer for sending frames with data. Space is left
621 * at the front for header bytes but that is treated as an implementation
622 * detail and not for the high level code to use
623 */
624
625static struct gsm_msg *gsm_data_alloc(struct gsm_mux *gsm, u8 addr, int len,
626 u8 ctrl)
627{
628 struct gsm_msg *m = kmalloc(sizeof(struct gsm_msg) + len + HDR_LEN,
629 GFP_ATOMIC);
630 if (m == NULL)
631 return NULL;
632 m->data = m->buffer + HDR_LEN - 1; /* Allow for FCS */
633 m->len = len;
634 m->addr = addr;
635 m->ctrl = ctrl;
636 m->next = NULL;
637 return m;
638}
639
640/**
641 * gsm_data_kick - poke the queue
642 * @gsm: GSM Mux
643 *
644 * The tty device has called us to indicate that room has appeared in
645 * the transmit queue. Ram more data into the pipe if we have any
646 *
647 * FIXME: lock against link layer control transmissions
648 */
649
650static void gsm_data_kick(struct gsm_mux *gsm)
651{
652 struct gsm_msg *msg = gsm->tx_head;
653 int len;
654 int skip_sof = 0;
655
656 /* FIXME: We need to apply this solely to data messages */
657 if (gsm->constipated)
658 return;
659
660 while (gsm->tx_head != NULL) {
661 msg = gsm->tx_head;
662 if (gsm->encoding != 0) {
663 gsm->txframe[0] = GSM1_SOF;
664 len = gsm_stuff_frame(msg->data,
665 gsm->txframe + 1, msg->len);
666 gsm->txframe[len + 1] = GSM1_SOF;
667 len += 2;
668 } else {
669 gsm->txframe[0] = GSM0_SOF;
670 memcpy(gsm->txframe + 1 , msg->data, msg->len);
671 gsm->txframe[msg->len + 1] = GSM0_SOF;
672 len = msg->len + 2;
673 }
674
675 if (debug & 4)
676 print_hex_dump_bytes("gsm_data_kick: ",
677 DUMP_PREFIX_OFFSET,
678 gsm->txframe, len);
679
680 if (gsm->output(gsm, gsm->txframe + skip_sof,
681 len - skip_sof) < 0)
682 break;
683 /* FIXME: Can eliminate one SOF in many more cases */
684 gsm->tx_head = msg->next;
685 if (gsm->tx_head == NULL)
686 gsm->tx_tail = NULL;
687 gsm->tx_bytes -= msg->len;
688 kfree(msg);
689 /* For a burst of frames skip the extra SOF within the
690 burst */
691 skip_sof = 1;
692 }
693}
694
695/**
696 * __gsm_data_queue - queue a UI or UIH frame
697 * @dlci: DLCI sending the data
698 * @msg: message queued
699 *
700 * Add data to the transmit queue and try and get stuff moving
701 * out of the mux tty if not already doing so. The Caller must hold
702 * the gsm tx lock.
703 */
704
705static void __gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
706{
707 struct gsm_mux *gsm = dlci->gsm;
708 u8 *dp = msg->data;
709 u8 *fcs = dp + msg->len;
710
711 /* Fill in the header */
712 if (gsm->encoding == 0) {
713 if (msg->len < 128)
714 *--dp = (msg->len << 1) | EA;
715 else {
716 *--dp = (msg->len >> 7); /* bits 7 - 15 */
717 *--dp = (msg->len & 127) << 1; /* bits 0 - 6 */
718 }
719 }
720
721 *--dp = msg->ctrl;
722 if (gsm->initiator)
723 *--dp = (msg->addr << 2) | 2 | EA;
724 else
725 *--dp = (msg->addr << 2) | EA;
726 *fcs = gsm_fcs_add_block(INIT_FCS, dp , msg->data - dp);
727 /* Ugly protocol layering violation */
728 if (msg->ctrl == UI || msg->ctrl == (UI|PF))
729 *fcs = gsm_fcs_add_block(*fcs, msg->data, msg->len);
730 *fcs = 0xFF - *fcs;
731
732 gsm_print_packet("Q> ", msg->addr, gsm->initiator, msg->ctrl,
733 msg->data, msg->len);
734
735 /* Move the header back and adjust the length, also allow for the FCS
736 now tacked on the end */
737 msg->len += (msg->data - dp) + 1;
738 msg->data = dp;
739
740 /* Add to the actual output queue */
741 if (gsm->tx_tail)
742 gsm->tx_tail->next = msg;
743 else
744 gsm->tx_head = msg;
745 gsm->tx_tail = msg;
746 gsm->tx_bytes += msg->len;
747 gsm_data_kick(gsm);
748}
749
750/**
751 * gsm_data_queue - queue a UI or UIH frame
752 * @dlci: DLCI sending the data
753 * @msg: message queued
754 *
755 * Add data to the transmit queue and try and get stuff moving
756 * out of the mux tty if not already doing so. Take the
757 * the gsm tx lock and dlci lock.
758 */
759
760static void gsm_data_queue(struct gsm_dlci *dlci, struct gsm_msg *msg)
761{
762 unsigned long flags;
763 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
764 __gsm_data_queue(dlci, msg);
765 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
766}
767
768/**
769 * gsm_dlci_data_output - try and push data out of a DLCI
770 * @gsm: mux
771 * @dlci: the DLCI to pull data from
772 *
773 * Pull data from a DLCI and send it into the transmit queue if there
774 * is data. Keep to the MRU of the mux. This path handles the usual tty
775 * interface which is a byte stream with optional modem data.
776 *
777 * Caller must hold the tx_lock of the mux.
778 */
779
780static int gsm_dlci_data_output(struct gsm_mux *gsm, struct gsm_dlci *dlci)
781{
782 struct gsm_msg *msg;
783 u8 *dp;
784 int len, size;
785 int h = dlci->adaption - 1;
786
787 len = kfifo_len(dlci->fifo);
788 if (len == 0)
789 return 0;
790
791 /* MTU/MRU count only the data bits */
792 if (len > gsm->mtu)
793 len = gsm->mtu;
794
795 size = len + h;
796
797 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
798 /* FIXME: need a timer or something to kick this so it can't
799 get stuck with no work outstanding and no buffer free */
800 if (msg == NULL)
801 return -ENOMEM;
802 dp = msg->data;
803 switch (dlci->adaption) {
804 case 1: /* Unstructured */
805 break;
806 case 2: /* Unstructed with modem bits. Always one byte as we never
807 send inline break data */
808 *dp += gsm_encode_modem(dlci);
809 len--;
810 break;
811 }
812 WARN_ON(kfifo_out_locked(dlci->fifo, dp , len, &dlci->lock) != len);
813 __gsm_data_queue(dlci, msg);
814 /* Bytes of data we used up */
815 return size;
816}
817
818/**
819 * gsm_dlci_data_output_framed - try and push data out of a DLCI
820 * @gsm: mux
821 * @dlci: the DLCI to pull data from
822 *
823 * Pull data from a DLCI and send it into the transmit queue if there
824 * is data. Keep to the MRU of the mux. This path handles framed data
825 * queued as skbuffs to the DLCI.
826 *
827 * Caller must hold the tx_lock of the mux.
828 */
829
830static int gsm_dlci_data_output_framed(struct gsm_mux *gsm,
831 struct gsm_dlci *dlci)
832{
833 struct gsm_msg *msg;
834 u8 *dp;
835 int len, size;
836 int last = 0, first = 0;
837 int overhead = 0;
838
839 /* One byte per frame is used for B/F flags */
840 if (dlci->adaption == 4)
841 overhead = 1;
842
843 /* dlci->skb is locked by tx_lock */
844 if (dlci->skb == NULL) {
845 dlci->skb = skb_dequeue(&dlci->skb_list);
846 if (dlci->skb == NULL)
847 return 0;
848 first = 1;
849 }
850 len = dlci->skb->len + overhead;
851
852 /* MTU/MRU count only the data bits */
853 if (len > gsm->mtu) {
854 if (dlci->adaption == 3) {
855 /* Over long frame, bin it */
856 kfree_skb(dlci->skb);
857 dlci->skb = NULL;
858 return 0;
859 }
860 len = gsm->mtu;
861 } else
862 last = 1;
863
864 size = len + overhead;
865 msg = gsm_data_alloc(gsm, dlci->addr, size, gsm->ftype);
866
867 /* FIXME: need a timer or something to kick this so it can't
868 get stuck with no work outstanding and no buffer free */
869 if (msg == NULL)
870 return -ENOMEM;
871 dp = msg->data;
872
873 if (dlci->adaption == 4) { /* Interruptible framed (Packetised Data) */
874 /* Flag byte to carry the start/end info */
875 *dp++ = last << 7 | first << 6 | 1; /* EA */
876 len--;
877 }
878 memcpy(dp, dlci->skb->data, len);
879 skb_pull(dlci->skb, len);
880 __gsm_data_queue(dlci, msg);
881 if (last)
882 dlci->skb = NULL;
883 return size;
884}
885
886/**
887 * gsm_dlci_data_sweep - look for data to send
888 * @gsm: the GSM mux
889 *
890 * Sweep the GSM mux channels in priority order looking for ones with
891 * data to send. We could do with optimising this scan a bit. We aim
892 * to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
893 * TX_THRESH_LO we get called again
894 *
895 * FIXME: We should round robin between groups and in theory you can
896 * renegotiate DLCI priorities with optional stuff. Needs optimising.
897 */
898
899static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
900{
901 int len;
902 /* Priority ordering: We should do priority with RR of the groups */
903 int i = 1;
904
905 while (i < NUM_DLCI) {
906 struct gsm_dlci *dlci;
907
908 if (gsm->tx_bytes > TX_THRESH_HI)
909 break;
910 dlci = gsm->dlci[i];
911 if (dlci == NULL || dlci->constipated) {
912 i++;
913 continue;
914 }
915 if (dlci->adaption < 3)
916 len = gsm_dlci_data_output(gsm, dlci);
917 else
918 len = gsm_dlci_data_output_framed(gsm, dlci);
919 if (len < 0)
920 break;
921 /* DLCI empty - try the next */
922 if (len == 0)
923 i++;
924 }
925}
926
927/**
928 * gsm_dlci_data_kick - transmit if possible
929 * @dlci: DLCI to kick
930 *
931 * Transmit data from this DLCI if the queue is empty. We can't rely on
932 * a tty wakeup except when we filled the pipe so we need to fire off
933 * new data ourselves in other cases.
934 */
935
936static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
937{
938 unsigned long flags;
939
940 spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
941 /* If we have nothing running then we need to fire up */
942 if (dlci->gsm->tx_bytes == 0)
943 gsm_dlci_data_output(dlci->gsm, dlci);
944 else if (dlci->gsm->tx_bytes < TX_THRESH_LO)
945 gsm_dlci_data_sweep(dlci->gsm);
946 spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
947}
948
949/*
950 * Control message processing
951 */
952
953
954/**
955 * gsm_control_reply - send a response frame to a control
956 * @gsm: gsm channel
957 * @cmd: the command to use
958 * @data: data to follow encoded info
959 * @dlen: length of data
960 *
961 * Encode up and queue a UI/UIH frame containing our response.
962 */
963
964static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
965 int dlen)
966{
967 struct gsm_msg *msg;
968 msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
969 if (msg == NULL)
970 return;
971 msg->data[0] = (cmd & 0xFE) << 1 | EA; /* Clear C/R */
972 msg->data[1] = (dlen << 1) | EA;
973 memcpy(msg->data + 2, data, dlen);
974 gsm_data_queue(gsm->dlci[0], msg);
975}
976
977/**
978 * gsm_process_modem - process received modem status
979 * @tty: virtual tty bound to the DLCI
980 * @dlci: DLCI to affect
981 * @modem: modem bits (full EA)
982 *
983 * Used when a modem control message or line state inline in adaption
984 * layer 2 is processed. Sort out the local modem state and throttles
985 */
986
987static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
988 u32 modem, int clen)
989{
990 int mlines = 0;
991 u8 brk = 0;
992
993 /* The modem status command can either contain one octet (v.24 signals)
994 or two octets (v.24 signals + break signals). The length field will
995 either be 2 or 3 respectively. This is specified in section
996 5.4.6.3.7 of the 27.010 mux spec. */
997
998 if (clen == 2)
999 modem = modem & 0x7f;
1000 else {
1001 brk = modem & 0x7f;
1002 modem = (modem >> 7) & 0x7f;
1003 };
1004
1005 /* Flow control/ready to communicate */
1006 if (modem & MDM_FC) {
1007 /* Need to throttle our output on this device */
1008 dlci->constipated = 1;
1009 }
1010 if (modem & MDM_RTC) {
1011 mlines |= TIOCM_DSR | TIOCM_DTR;
1012 dlci->constipated = 0;
1013 gsm_dlci_data_kick(dlci);
1014 }
1015 /* Map modem bits */
1016 if (modem & MDM_RTR)
1017 mlines |= TIOCM_RTS | TIOCM_CTS;
1018 if (modem & MDM_IC)
1019 mlines |= TIOCM_RI;
1020 if (modem & MDM_DV)
1021 mlines |= TIOCM_CD;
1022
1023 /* Carrier drop -> hangup */
1024 if (tty) {
1025 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1026 if (!(tty->termios->c_cflag & CLOCAL))
1027 tty_hangup(tty);
1028 if (brk & 0x01)
1029 tty_insert_flip_char(tty, 0, TTY_BREAK);
1030 }
1031 dlci->modem_rx = mlines;
1032}
1033
1034/**
1035 * gsm_control_modem - modem status received
1036 * @gsm: GSM channel
1037 * @data: data following command
1038 * @clen: command length
1039 *
1040 * We have received a modem status control message. This is used by
1041 * the GSM mux protocol to pass virtual modem line status and optionally
1042 * to indicate break signals. Unpack it, convert to Linux representation
1043 * and if need be stuff a break message down the tty.
1044 */
1045
1046static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1047{
1048 unsigned int addr = 0;
1049 unsigned int modem = 0;
1050 struct gsm_dlci *dlci;
1051 int len = clen;
1052 u8 *dp = data;
1053 struct tty_struct *tty;
1054
1055 while (gsm_read_ea(&addr, *dp++) == 0) {
1056 len--;
1057 if (len == 0)
1058 return;
1059 }
1060 /* Must be at least one byte following the EA */
1061 len--;
1062 if (len <= 0)
1063 return;
1064
1065 addr >>= 1;
1066 /* Closed port, or invalid ? */
1067 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1068 return;
1069 dlci = gsm->dlci[addr];
1070
1071 while (gsm_read_ea(&modem, *dp++) == 0) {
1072 len--;
1073 if (len == 0)
1074 return;
1075 }
1076 tty = tty_port_tty_get(&dlci->port);
1077 gsm_process_modem(tty, dlci, modem, clen);
1078 if (tty) {
1079 tty_wakeup(tty);
1080 tty_kref_put(tty);
1081 }
1082 gsm_control_reply(gsm, CMD_MSC, data, clen);
1083}
1084
1085/**
1086 * gsm_control_rls - remote line status
1087 * @gsm: GSM channel
1088 * @data: data bytes
1089 * @clen: data length
1090 *
1091 * The modem sends us a two byte message on the control channel whenever
1092 * it wishes to send us an error state from the virtual link. Stuff
1093 * this into the uplink tty if present
1094 */
1095
1096static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1097{
1098 struct tty_struct *tty;
1099 unsigned int addr = 0 ;
1100 u8 bits;
1101 int len = clen;
1102 u8 *dp = data;
1103
1104 while (gsm_read_ea(&addr, *dp++) == 0) {
1105 len--;
1106 if (len == 0)
1107 return;
1108 }
1109 /* Must be at least one byte following ea */
1110 len--;
1111 if (len <= 0)
1112 return;
1113 addr >>= 1;
1114 /* Closed port, or invalid ? */
1115 if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1116 return;
1117 /* No error ? */
1118 bits = *dp;
1119 if ((bits & 1) == 0)
1120 return;
1121 /* See if we have an uplink tty */
1122 tty = tty_port_tty_get(&gsm->dlci[addr]->port);
1123
1124 if (tty) {
1125 if (bits & 2)
1126 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1127 if (bits & 4)
1128 tty_insert_flip_char(tty, 0, TTY_PARITY);
1129 if (bits & 8)
1130 tty_insert_flip_char(tty, 0, TTY_FRAME);
1131 tty_flip_buffer_push(tty);
1132 tty_kref_put(tty);
1133 }
1134 gsm_control_reply(gsm, CMD_RLS, data, clen);
1135}
1136
1137static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1138
1139/**
1140 * gsm_control_message - DLCI 0 control processing
1141 * @gsm: our GSM mux
1142 * @command: the command EA
1143 * @data: data beyond the command/length EAs
1144 * @clen: length
1145 *
1146 * Input processor for control messages from the other end of the link.
1147 * Processes the incoming request and queues a response frame or an
1148 * NSC response if not supported
1149 */
1150
1151static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1152 u8 *data, int clen)
1153{
1154 u8 buf[1];
1155 switch (command) {
1156 case CMD_CLD: {
1157 struct gsm_dlci *dlci = gsm->dlci[0];
1158 /* Modem wishes to close down */
1159 if (dlci) {
1160 dlci->dead = 1;
1161 gsm->dead = 1;
1162 gsm_dlci_begin_close(dlci);
1163 }
1164 }
1165 break;
1166 case CMD_TEST:
1167 /* Modem wishes to test, reply with the data */
1168 gsm_control_reply(gsm, CMD_TEST, data, clen);
1169 break;
1170 case CMD_FCON:
1171 /* Modem wants us to STFU */
1172 gsm->constipated = 1;
1173 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1174 break;
1175 case CMD_FCOFF:
1176 /* Modem can accept data again */
1177 gsm->constipated = 0;
1178 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1179 /* Kick the link in case it is idling */
1180 gsm_data_kick(gsm);
1181 break;
1182 case CMD_MSC:
1183 /* Out of band modem line change indicator for a DLCI */
1184 gsm_control_modem(gsm, data, clen);
1185 break;
1186 case CMD_RLS:
1187 /* Out of band error reception for a DLCI */
1188 gsm_control_rls(gsm, data, clen);
1189 break;
1190 case CMD_PSC:
1191 /* Modem wishes to enter power saving state */
1192 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1193 break;
1194 /* Optional unsupported commands */
1195 case CMD_PN: /* Parameter negotiation */
1196 case CMD_RPN: /* Remote port negotiation */
1197 case CMD_SNC: /* Service negotiation command */
1198 default:
1199 /* Reply to bad commands with an NSC */
1200 buf[0] = command;
1201 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1202 break;
1203 }
1204}
1205
1206/**
1207 * gsm_control_response - process a response to our control
1208 * @gsm: our GSM mux
1209 * @command: the command (response) EA
1210 * @data: data beyond the command/length EA
1211 * @clen: length
1212 *
1213 * Process a response to an outstanding command. We only allow a single
1214 * control message in flight so this is fairly easy. All the clean up
1215 * is done by the caller, we just update the fields, flag it as done
1216 * and return
1217 */
1218
1219static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1220 u8 *data, int clen)
1221{
1222 struct gsm_control *ctrl;
1223 unsigned long flags;
1224
1225 spin_lock_irqsave(&gsm->control_lock, flags);
1226
1227 ctrl = gsm->pending_cmd;
1228 /* Does the reply match our command */
1229 command |= 1;
1230 if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1231 /* Our command was replied to, kill the retry timer */
1232 del_timer(&gsm->t2_timer);
1233 gsm->pending_cmd = NULL;
1234 /* Rejected by the other end */
1235 if (command == CMD_NSC)
1236 ctrl->error = -EOPNOTSUPP;
1237 ctrl->done = 1;
1238 wake_up(&gsm->event);
1239 }
1240 spin_unlock_irqrestore(&gsm->control_lock, flags);
1241}
1242
1243/**
1244 * gsm_control_transmit - send control packet
1245 * @gsm: gsm mux
1246 * @ctrl: frame to send
1247 *
1248 * Send out a pending control command (called under control lock)
1249 */
1250
1251static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1252{
1253 struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype);
1254 if (msg == NULL)
1255 return;
1256 msg->data[0] = (ctrl->cmd << 1) | 2 | EA; /* command */
1257 memcpy(msg->data + 1, ctrl->data, ctrl->len);
1258 gsm_data_queue(gsm->dlci[0], msg);
1259}
1260
1261/**
1262 * gsm_control_retransmit - retransmit a control frame
1263 * @data: pointer to our gsm object
1264 *
1265 * Called off the T2 timer expiry in order to retransmit control frames
1266 * that have been lost in the system somewhere. The control_lock protects
1267 * us from colliding with another sender or a receive completion event.
1268 * In that situation the timer may still occur in a small window but
1269 * gsm->pending_cmd will be NULL and we just let the timer expire.
1270 */
1271
1272static void gsm_control_retransmit(unsigned long data)
1273{
1274 struct gsm_mux *gsm = (struct gsm_mux *)data;
1275 struct gsm_control *ctrl;
1276 unsigned long flags;
1277 spin_lock_irqsave(&gsm->control_lock, flags);
1278 ctrl = gsm->pending_cmd;
1279 if (ctrl) {
1280 gsm->cretries--;
1281 if (gsm->cretries == 0) {
1282 gsm->pending_cmd = NULL;
1283 ctrl->error = -ETIMEDOUT;
1284 ctrl->done = 1;
1285 spin_unlock_irqrestore(&gsm->control_lock, flags);
1286 wake_up(&gsm->event);
1287 return;
1288 }
1289 gsm_control_transmit(gsm, ctrl);
1290 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1291 }
1292 spin_unlock_irqrestore(&gsm->control_lock, flags);
1293}
1294
1295/**
1296 * gsm_control_send - send a control frame on DLCI 0
1297 * @gsm: the GSM channel
1298 * @command: command to send including CR bit
1299 * @data: bytes of data (must be kmalloced)
1300 * @len: length of the block to send
1301 *
1302 * Queue and dispatch a control command. Only one command can be
1303 * active at a time. In theory more can be outstanding but the matching
1304 * gets really complicated so for now stick to one outstanding.
1305 */
1306
1307static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1308 unsigned int command, u8 *data, int clen)
1309{
1310 struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1311 GFP_KERNEL);
1312 unsigned long flags;
1313 if (ctrl == NULL)
1314 return NULL;
1315retry:
1316 wait_event(gsm->event, gsm->pending_cmd == NULL);
1317 spin_lock_irqsave(&gsm->control_lock, flags);
1318 if (gsm->pending_cmd != NULL) {
1319 spin_unlock_irqrestore(&gsm->control_lock, flags);
1320 goto retry;
1321 }
1322 ctrl->cmd = command;
1323 ctrl->data = data;
1324 ctrl->len = clen;
1325 gsm->pending_cmd = ctrl;
1326 gsm->cretries = gsm->n2;
1327 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1328 gsm_control_transmit(gsm, ctrl);
1329 spin_unlock_irqrestore(&gsm->control_lock, flags);
1330 return ctrl;
1331}
1332
1333/**
1334 * gsm_control_wait - wait for a control to finish
1335 * @gsm: GSM mux
1336 * @control: control we are waiting on
1337 *
1338 * Waits for the control to complete or time out. Frees any used
1339 * resources and returns 0 for success, or an error if the remote
1340 * rejected or ignored the request.
1341 */
1342
1343static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1344{
1345 int err;
1346 wait_event(gsm->event, control->done == 1);
1347 err = control->error;
1348 kfree(control);
1349 return err;
1350}
1351
1352
1353/*
1354 * DLCI level handling: Needs krefs
1355 */
1356
1357/*
1358 * State transitions and timers
1359 */
1360
1361/**
1362 * gsm_dlci_close - a DLCI has closed
1363 * @dlci: DLCI that closed
1364 *
1365 * Perform processing when moving a DLCI into closed state. If there
1366 * is an attached tty this is hung up
1367 */
1368
1369static void gsm_dlci_close(struct gsm_dlci *dlci)
1370{
1371 del_timer(&dlci->t1);
1372 if (debug & 8)
1373 pr_debug("DLCI %d goes closed.\n", dlci->addr);
1374 dlci->state = DLCI_CLOSED;
1375 if (dlci->addr != 0) {
1376 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1377 if (tty) {
1378 tty_hangup(tty);
1379 tty_kref_put(tty);
1380 }
1381 kfifo_reset(dlci->fifo);
1382 } else
1383 dlci->gsm->dead = 1;
1384 wake_up(&dlci->gsm->event);
1385 /* A DLCI 0 close is a MUX termination so we need to kick that
1386 back to userspace somehow */
1387}
1388
1389/**
1390 * gsm_dlci_open - a DLCI has opened
1391 * @dlci: DLCI that opened
1392 *
1393 * Perform processing when moving a DLCI into open state.
1394 */
1395
1396static void gsm_dlci_open(struct gsm_dlci *dlci)
1397{
1398 /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1399 open -> open */
1400 del_timer(&dlci->t1);
1401 /* This will let a tty open continue */
1402 dlci->state = DLCI_OPEN;
1403 if (debug & 8)
1404 pr_debug("DLCI %d goes open.\n", dlci->addr);
1405 wake_up(&dlci->gsm->event);
1406}
1407
1408/**
1409 * gsm_dlci_t1 - T1 timer expiry
1410 * @dlci: DLCI that opened
1411 *
1412 * The T1 timer handles retransmits of control frames (essentially of
1413 * SABM and DISC). We resend the command until the retry count runs out
1414 * in which case an opening port goes back to closed and a closing port
1415 * is simply put into closed state (any further frames from the other
1416 * end will get a DM response)
1417 */
1418
1419static void gsm_dlci_t1(unsigned long data)
1420{
1421 struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1422 struct gsm_mux *gsm = dlci->gsm;
1423
1424 switch (dlci->state) {
1425 case DLCI_OPENING:
1426 dlci->retries--;
1427 if (dlci->retries) {
1428 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1429 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1430 } else
1431 gsm_dlci_close(dlci);
1432 break;
1433 case DLCI_CLOSING:
1434 dlci->retries--;
1435 if (dlci->retries) {
1436 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1437 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1438 } else
1439 gsm_dlci_close(dlci);
1440 break;
1441 }
1442}
1443
1444/**
1445 * gsm_dlci_begin_open - start channel open procedure
1446 * @dlci: DLCI to open
1447 *
1448 * Commence opening a DLCI from the Linux side. We issue SABM messages
1449 * to the modem which should then reply with a UA, at which point we
1450 * will move into open state. Opening is done asynchronously with retry
1451 * running off timers and the responses.
1452 */
1453
1454static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1455{
1456 struct gsm_mux *gsm = dlci->gsm;
1457 if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1458 return;
1459 dlci->retries = gsm->n2;
1460 dlci->state = DLCI_OPENING;
1461 gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1462 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1463}
1464
1465/**
1466 * gsm_dlci_begin_close - start channel open procedure
1467 * @dlci: DLCI to open
1468 *
1469 * Commence closing a DLCI from the Linux side. We issue DISC messages
1470 * to the modem which should then reply with a UA, at which point we
1471 * will move into closed state. Closing is done asynchronously with retry
1472 * off timers. We may also receive a DM reply from the other end which
1473 * indicates the channel was already closed.
1474 */
1475
1476static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1477{
1478 struct gsm_mux *gsm = dlci->gsm;
1479 if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1480 return;
1481 dlci->retries = gsm->n2;
1482 dlci->state = DLCI_CLOSING;
1483 gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1484 mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1485}
1486
1487/**
1488 * gsm_dlci_data - data arrived
1489 * @dlci: channel
1490 * @data: block of bytes received
1491 * @len: length of received block
1492 *
1493 * A UI or UIH frame has arrived which contains data for a channel
1494 * other than the control channel. If the relevant virtual tty is
1495 * open we shovel the bits down it, if not we drop them.
1496 */
1497
1498static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int clen)
1499{
1500 /* krefs .. */
1501 struct tty_port *port = &dlci->port;
1502 struct tty_struct *tty = tty_port_tty_get(port);
1503 unsigned int modem = 0;
1504 int len = clen;
1505
1506 if (debug & 16)
1507 pr_debug("%d bytes for tty %p\n", len, tty);
1508 if (tty) {
1509 switch (dlci->adaption) {
1510 /* Unsupported types */
1511 /* Packetised interruptible data */
1512 case 4:
1513 break;
1514 /* Packetised uininterruptible voice/data */
1515 case 3:
1516 break;
1517 /* Asynchronous serial with line state in each frame */
1518 case 2:
1519 while (gsm_read_ea(&modem, *data++) == 0) {
1520 len--;
1521 if (len == 0)
1522 return;
1523 }
1524 gsm_process_modem(tty, dlci, modem, clen);
1525 /* Line state will go via DLCI 0 controls only */
1526 case 1:
1527 default:
1528 tty_insert_flip_string(tty, data, len);
1529 tty_flip_buffer_push(tty);
1530 }
1531 tty_kref_put(tty);
1532 }
1533}
1534
1535/**
1536 * gsm_dlci_control - data arrived on control channel
1537 * @dlci: channel
1538 * @data: block of bytes received
1539 * @len: length of received block
1540 *
1541 * A UI or UIH frame has arrived which contains data for DLCI 0 the
1542 * control channel. This should contain a command EA followed by
1543 * control data bytes. The command EA contains a command/response bit
1544 * and we divide up the work accordingly.
1545 */
1546
1547static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1548{
1549 /* See what command is involved */
1550 unsigned int command = 0;
1551 while (len-- > 0) {
1552 if (gsm_read_ea(&command, *data++) == 1) {
1553 int clen = *data++;
1554 len--;
1555 /* FIXME: this is properly an EA */
1556 clen >>= 1;
1557 /* Malformed command ? */
1558 if (clen > len)
1559 return;
1560 if (command & 1)
1561 gsm_control_message(dlci->gsm, command,
1562 data, clen);
1563 else
1564 gsm_control_response(dlci->gsm, command,
1565 data, clen);
1566 return;
1567 }
1568 }
1569}
1570
1571/*
1572 * Allocate/Free DLCI channels
1573 */
1574
1575/**
1576 * gsm_dlci_alloc - allocate a DLCI
1577 * @gsm: GSM mux
1578 * @addr: address of the DLCI
1579 *
1580 * Allocate and install a new DLCI object into the GSM mux.
1581 *
1582 * FIXME: review locking races
1583 */
1584
1585static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1586{
1587 struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1588 if (dlci == NULL)
1589 return NULL;
1590 spin_lock_init(&dlci->lock);
1591 dlci->fifo = &dlci->_fifo;
1592 if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1593 kfree(dlci);
1594 return NULL;
1595 }
1596
1597 skb_queue_head_init(&dlci->skb_list);
1598 init_timer(&dlci->t1);
1599 dlci->t1.function = gsm_dlci_t1;
1600 dlci->t1.data = (unsigned long)dlci;
1601 tty_port_init(&dlci->port);
1602 dlci->port.ops = &gsm_port_ops;
1603 dlci->gsm = gsm;
1604 dlci->addr = addr;
1605 dlci->adaption = gsm->adaption;
1606 dlci->state = DLCI_CLOSED;
1607 if (addr)
1608 dlci->data = gsm_dlci_data;
1609 else
1610 dlci->data = gsm_dlci_command;
1611 gsm->dlci[addr] = dlci;
1612 return dlci;
1613}
1614
1615/**
1616 * gsm_dlci_free - release DLCI
1617 * @dlci: DLCI to destroy
1618 *
1619 * Free up a DLCI. Currently to keep the lifetime rules sane we only
1620 * clean up DLCI objects when the MUX closes rather than as the port
1621 * is closed down on both the tty and mux levels.
1622 *
1623 * Can sleep.
1624 */
1625static void gsm_dlci_free(struct gsm_dlci *dlci)
1626{
1627 struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1628 if (tty) {
1629 tty_vhangup(tty);
1630 tty_kref_put(tty);
1631 }
1632 del_timer_sync(&dlci->t1);
1633 dlci->gsm->dlci[dlci->addr] = NULL;
1634 kfifo_free(dlci->fifo);
1635 kfree(dlci);
1636}
1637
1638/*
1639 * LAPBish link layer logic
1640 */
1641
1642/**
1643 * gsm_queue - a GSM frame is ready to process
1644 * @gsm: pointer to our gsm mux
1645 *
1646 * At this point in time a frame has arrived and been demangled from
1647 * the line encoding. All the differences between the encodings have
1648 * been handled below us and the frame is unpacked into the structures.
1649 * The fcs holds the header FCS but any data FCS must be added here.
1650 */
1651
1652static void gsm_queue(struct gsm_mux *gsm)
1653{
1654 struct gsm_dlci *dlci;
1655 u8 cr;
1656 int address;
1657 /* We have to sneak a look at the packet body to do the FCS.
1658 A somewhat layering violation in the spec */
1659
1660 if ((gsm->control & ~PF) == UI)
1661 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1662 if (gsm->encoding == 0){
1663 /* WARNING: gsm->received_fcs is used for gsm->encoding = 0 only.
1664 In this case it contain the last piece of data
1665 required to generate final CRC */
1666 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1667 }
1668 if (gsm->fcs != GOOD_FCS) {
1669 gsm->bad_fcs++;
1670 if (debug & 4)
1671 pr_debug("BAD FCS %02x\n", gsm->fcs);
1672 return;
1673 }
1674 address = gsm->address >> 1;
1675 if (address >= NUM_DLCI)
1676 goto invalid;
1677
1678 cr = gsm->address & 1; /* C/R bit */
1679
1680 gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1681
1682 cr ^= 1 - gsm->initiator; /* Flip so 1 always means command */
1683 dlci = gsm->dlci[address];
1684
1685 switch (gsm->control) {
1686 case SABM|PF:
1687 if (cr == 0)
1688 goto invalid;
1689 if (dlci == NULL)
1690 dlci = gsm_dlci_alloc(gsm, address);
1691 if (dlci == NULL)
1692 return;
1693 if (dlci->dead)
1694 gsm_response(gsm, address, DM);
1695 else {
1696 gsm_response(gsm, address, UA);
1697 gsm_dlci_open(dlci);
1698 }
1699 break;
1700 case DISC|PF:
1701 if (cr == 0)
1702 goto invalid;
1703 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1704 gsm_response(gsm, address, DM);
1705 return;
1706 }
1707 /* Real close complete */
1708 gsm_response(gsm, address, UA);
1709 gsm_dlci_close(dlci);
1710 break;
1711 case UA:
1712 case UA|PF:
1713 if (cr == 0 || dlci == NULL)
1714 break;
1715 switch (dlci->state) {
1716 case DLCI_CLOSING:
1717 gsm_dlci_close(dlci);
1718 break;
1719 case DLCI_OPENING:
1720 gsm_dlci_open(dlci);
1721 break;
1722 }
1723 break;
1724 case DM: /* DM can be valid unsolicited */
1725 case DM|PF:
1726 if (cr)
1727 goto invalid;
1728 if (dlci == NULL)
1729 return;
1730 gsm_dlci_close(dlci);
1731 break;
1732 case UI:
1733 case UI|PF:
1734 case UIH:
1735 case UIH|PF:
1736#if 0
1737 if (cr)
1738 goto invalid;
1739#endif
1740 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1741 gsm_command(gsm, address, DM|PF);
1742 return;
1743 }
1744 dlci->data(dlci, gsm->buf, gsm->len);
1745 break;
1746 default:
1747 goto invalid;
1748 }
1749 return;
1750invalid:
1751 gsm->malformed++;
1752 return;
1753}
1754
1755
1756/**
1757 * gsm0_receive - perform processing for non-transparency
1758 * @gsm: gsm data for this ldisc instance
1759 * @c: character
1760 *
1761 * Receive bytes in gsm mode 0
1762 */
1763
1764static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1765{
1766 unsigned int len;
1767
1768 switch (gsm->state) {
1769 case GSM_SEARCH: /* SOF marker */
1770 if (c == GSM0_SOF) {
1771 gsm->state = GSM_ADDRESS;
1772 gsm->address = 0;
1773 gsm->len = 0;
1774 gsm->fcs = INIT_FCS;
1775 }
1776 break;
1777 case GSM_ADDRESS: /* Address EA */
1778 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1779 if (gsm_read_ea(&gsm->address, c))
1780 gsm->state = GSM_CONTROL;
1781 break;
1782 case GSM_CONTROL: /* Control Byte */
1783 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1784 gsm->control = c;
1785 gsm->state = GSM_LEN0;
1786 break;
1787 case GSM_LEN0: /* Length EA */
1788 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1789 if (gsm_read_ea(&gsm->len, c)) {
1790 if (gsm->len > gsm->mru) {
1791 gsm->bad_size++;
1792 gsm->state = GSM_SEARCH;
1793 break;
1794 }
1795 gsm->count = 0;
1796 if (!gsm->len)
1797 gsm->state = GSM_FCS;
1798 else
1799 gsm->state = GSM_DATA;
1800 break;
1801 }
1802 gsm->state = GSM_LEN1;
1803 break;
1804 case GSM_LEN1:
1805 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1806 len = c;
1807 gsm->len |= len << 7;
1808 if (gsm->len > gsm->mru) {
1809 gsm->bad_size++;
1810 gsm->state = GSM_SEARCH;
1811 break;
1812 }
1813 gsm->count = 0;
1814 if (!gsm->len)
1815 gsm->state = GSM_FCS;
1816 else
1817 gsm->state = GSM_DATA;
1818 break;
1819 case GSM_DATA: /* Data */
1820 gsm->buf[gsm->count++] = c;
1821 if (gsm->count == gsm->len)
1822 gsm->state = GSM_FCS;
1823 break;
1824 case GSM_FCS: /* FCS follows the packet */
1825 gsm->received_fcs = c;
1826 if (c == GSM0_SOF) {
1827 gsm->state = GSM_SEARCH;
1828 break;
1829 }
1830 gsm_queue(gsm);
1831 gsm->state = GSM_SSOF;
1832 break;
1833 case GSM_SSOF:
1834 if (c == GSM0_SOF) {
1835 gsm->state = GSM_SEARCH;
1836 break;
1837 }
1838 break;
1839 }
1840}
1841
1842/**
1843 * gsm1_receive - perform processing for non-transparency
1844 * @gsm: gsm data for this ldisc instance
1845 * @c: character
1846 *
1847 * Receive bytes in mode 1 (Advanced option)
1848 */
1849
1850static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1851{
1852 if (c == GSM1_SOF) {
1853 /* EOF is only valid in frame if we have got to the data state
1854 and received at least one byte (the FCS) */
1855 if (gsm->state == GSM_DATA && gsm->count) {
1856 /* Extract the FCS */
1857 gsm->count--;
1858 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1859 gsm->len = gsm->count;
1860 gsm_queue(gsm);
1861 gsm->state = GSM_START;
1862 return;
1863 }
1864 /* Any partial frame was a runt so go back to start */
1865 if (gsm->state != GSM_START) {
1866 gsm->malformed++;
1867 gsm->state = GSM_START;
1868 }
1869 /* A SOF in GSM_START means we are still reading idling or
1870 framing bytes */
1871 return;
1872 }
1873
1874 if (c == GSM1_ESCAPE) {
1875 gsm->escape = 1;
1876 return;
1877 }
1878
1879 /* Only an unescaped SOF gets us out of GSM search */
1880 if (gsm->state == GSM_SEARCH)
1881 return;
1882
1883 if (gsm->escape) {
1884 c ^= GSM1_ESCAPE_BITS;
1885 gsm->escape = 0;
1886 }
1887 switch (gsm->state) {
1888 case GSM_START: /* First byte after SOF */
1889 gsm->address = 0;
1890 gsm->state = GSM_ADDRESS;
1891 gsm->fcs = INIT_FCS;
1892 /* Drop through */
1893 case GSM_ADDRESS: /* Address continuation */
1894 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1895 if (gsm_read_ea(&gsm->address, c))
1896 gsm->state = GSM_CONTROL;
1897 break;
1898 case GSM_CONTROL: /* Control Byte */
1899 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1900 gsm->control = c;
1901 gsm->count = 0;
1902 gsm->state = GSM_DATA;
1903 break;
1904 case GSM_DATA: /* Data */
1905 if (gsm->count > gsm->mru) { /* Allow one for the FCS */
1906 gsm->state = GSM_OVERRUN;
1907 gsm->bad_size++;
1908 } else
1909 gsm->buf[gsm->count++] = c;
1910 break;
1911 case GSM_OVERRUN: /* Over-long - eg a dropped SOF */
1912 break;
1913 }
1914}
1915
1916/**
1917 * gsm_error - handle tty error
1918 * @gsm: ldisc data
1919 * @data: byte received (may be invalid)
1920 * @flag: error received
1921 *
1922 * Handle an error in the receipt of data for a frame. Currently we just
1923 * go back to hunting for a SOF.
1924 *
1925 * FIXME: better diagnostics ?
1926 */
1927
1928static void gsm_error(struct gsm_mux *gsm,
1929 unsigned char data, unsigned char flag)
1930{
1931 gsm->state = GSM_SEARCH;
1932 gsm->io_error++;
1933}
1934
1935/**
1936 * gsm_cleanup_mux - generic GSM protocol cleanup
1937 * @gsm: our mux
1938 *
1939 * Clean up the bits of the mux which are the same for all framing
1940 * protocols. Remove the mux from the mux table, stop all the timers
1941 * and then shut down each device hanging up the channels as we go.
1942 */
1943
1944void gsm_cleanup_mux(struct gsm_mux *gsm)
1945{
1946 int i;
1947 struct gsm_dlci *dlci = gsm->dlci[0];
1948 struct gsm_msg *txq;
1949
1950 gsm->dead = 1;
1951
1952 spin_lock(&gsm_mux_lock);
1953 for (i = 0; i < MAX_MUX; i++) {
1954 if (gsm_mux[i] == gsm) {
1955 gsm_mux[i] = NULL;
1956 break;
1957 }
1958 }
1959 spin_unlock(&gsm_mux_lock);
1960 WARN_ON(i == MAX_MUX);
1961
1962 del_timer_sync(&gsm->t2_timer);
1963 /* Now we are sure T2 has stopped */
1964 if (dlci) {
1965 dlci->dead = 1;
1966 gsm_dlci_begin_close(dlci);
1967 wait_event_interruptible(gsm->event,
1968 dlci->state == DLCI_CLOSED);
1969 }
1970 /* Free up any link layer users */
1971 for (i = 0; i < NUM_DLCI; i++)
1972 if (gsm->dlci[i])
1973 gsm_dlci_free(gsm->dlci[i]);
1974 /* Now wipe the queues */
1975 for (txq = gsm->tx_head; txq != NULL; txq = gsm->tx_head) {
1976 gsm->tx_head = txq->next;
1977 kfree(txq);
1978 }
1979 gsm->tx_tail = NULL;
1980}
1981EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
1982
1983/**
1984 * gsm_activate_mux - generic GSM setup
1985 * @gsm: our mux
1986 *
1987 * Set up the bits of the mux which are the same for all framing
1988 * protocols. Add the mux to the mux table so it can be opened and
1989 * finally kick off connecting to DLCI 0 on the modem.
1990 */
1991
1992int gsm_activate_mux(struct gsm_mux *gsm)
1993{
1994 struct gsm_dlci *dlci;
1995 int i = 0;
1996
1997 init_timer(&gsm->t2_timer);
1998 gsm->t2_timer.function = gsm_control_retransmit;
1999 gsm->t2_timer.data = (unsigned long)gsm;
2000 init_waitqueue_head(&gsm->event);
2001 spin_lock_init(&gsm->control_lock);
2002 spin_lock_init(&gsm->tx_lock);
2003
2004 if (gsm->encoding == 0)
2005 gsm->receive = gsm0_receive;
2006 else
2007 gsm->receive = gsm1_receive;
2008 gsm->error = gsm_error;
2009
2010 spin_lock(&gsm_mux_lock);
2011 for (i = 0; i < MAX_MUX; i++) {
2012 if (gsm_mux[i] == NULL) {
2013 gsm_mux[i] = gsm;
2014 break;
2015 }
2016 }
2017 spin_unlock(&gsm_mux_lock);
2018 if (i == MAX_MUX)
2019 return -EBUSY;
2020
2021 dlci = gsm_dlci_alloc(gsm, 0);
2022 if (dlci == NULL)
2023 return -ENOMEM;
2024 gsm->dead = 0; /* Tty opens are now permissible */
2025 return 0;
2026}
2027EXPORT_SYMBOL_GPL(gsm_activate_mux);
2028
2029/**
2030 * gsm_free_mux - free up a mux
2031 * @mux: mux to free
2032 *
2033 * Dispose of allocated resources for a dead mux. No refcounting
2034 * at present so the mux must be truly dead.
2035 */
2036void gsm_free_mux(struct gsm_mux *gsm)
2037{
2038 kfree(gsm->txframe);
2039 kfree(gsm->buf);
2040 kfree(gsm);
2041}
2042EXPORT_SYMBOL_GPL(gsm_free_mux);
2043
2044/**
2045 * gsm_alloc_mux - allocate a mux
2046 *
2047 * Creates a new mux ready for activation.
2048 */
2049
2050struct gsm_mux *gsm_alloc_mux(void)
2051{
2052 struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2053 if (gsm == NULL)
2054 return NULL;
2055 gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2056 if (gsm->buf == NULL) {
2057 kfree(gsm);
2058 return NULL;
2059 }
2060 gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2061 if (gsm->txframe == NULL) {
2062 kfree(gsm->buf);
2063 kfree(gsm);
2064 return NULL;
2065 }
2066 spin_lock_init(&gsm->lock);
2067
2068 gsm->t1 = T1;
2069 gsm->t2 = T2;
2070 gsm->n2 = N2;
2071 gsm->ftype = UIH;
2072 gsm->initiator = 0;
2073 gsm->adaption = 1;
2074 gsm->encoding = 1;
2075 gsm->mru = 64; /* Default to encoding 1 so these should be 64 */
2076 gsm->mtu = 64;
2077 gsm->dead = 1; /* Avoid early tty opens */
2078
2079 return gsm;
2080}
2081EXPORT_SYMBOL_GPL(gsm_alloc_mux);
2082
2083/**
2084 * gsmld_output - write to link
2085 * @gsm: our mux
2086 * @data: bytes to output
2087 * @len: size
2088 *
2089 * Write a block of data from the GSM mux to the data channel. This
2090 * will eventually be serialized from above but at the moment isn't.
2091 */
2092
2093static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2094{
2095 if (tty_write_room(gsm->tty) < len) {
2096 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2097 return -ENOSPC;
2098 }
2099 if (debug & 4)
2100 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET,
2101 data, len);
2102 gsm->tty->ops->write(gsm->tty, data, len);
2103 return len;
2104}
2105
2106/**
2107 * gsmld_attach_gsm - mode set up
2108 * @tty: our tty structure
2109 * @gsm: our mux
2110 *
2111 * Set up the MUX for basic mode and commence connecting to the
2112 * modem. Currently called from the line discipline set up but
2113 * will need moving to an ioctl path.
2114 */
2115
2116static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2117{
2118 int ret;
2119
2120 gsm->tty = tty_kref_get(tty);
2121 gsm->output = gsmld_output;
2122 ret = gsm_activate_mux(gsm);
2123 if (ret != 0)
2124 tty_kref_put(gsm->tty);
2125 return ret;
2126}
2127
2128
2129/**
2130 * gsmld_detach_gsm - stop doing 0710 mux
2131 * @tty: tty attached to the mux
2132 * @gsm: mux
2133 *
2134 * Shutdown and then clean up the resources used by the line discipline
2135 */
2136
2137static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2138{
2139 WARN_ON(tty != gsm->tty);
2140 gsm_cleanup_mux(gsm);
2141 tty_kref_put(gsm->tty);
2142 gsm->tty = NULL;
2143}
2144
2145static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2146 char *fp, int count)
2147{
2148 struct gsm_mux *gsm = tty->disc_data;
2149 const unsigned char *dp;
2150 char *f;
2151 int i;
2152 char buf[64];
2153 char flags;
2154
2155 if (debug & 4)
2156 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET,
2157 cp, count);
2158
2159 for (i = count, dp = cp, f = fp; i; i--, dp++) {
2160 flags = *f++;
2161 switch (flags) {
2162 case TTY_NORMAL:
2163 gsm->receive(gsm, *dp);
2164 break;
2165 case TTY_OVERRUN:
2166 case TTY_BREAK:
2167 case TTY_PARITY:
2168 case TTY_FRAME:
2169 gsm->error(gsm, *dp, flags);
2170 break;
2171 default:
2172 WARN_ONCE("%s: unknown flag %d\n",
2173 tty_name(tty, buf), flags);
2174 break;
2175 }
2176 }
2177 /* FASYNC if needed ? */
2178 /* If clogged call tty_throttle(tty); */
2179}
2180
2181/**
2182 * gsmld_chars_in_buffer - report available bytes
2183 * @tty: tty device
2184 *
2185 * Report the number of characters buffered to be delivered to user
2186 * at this instant in time.
2187 *
2188 * Locking: gsm lock
2189 */
2190
2191static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
2192{
2193 return 0;
2194}
2195
2196/**
2197 * gsmld_flush_buffer - clean input queue
2198 * @tty: terminal device
2199 *
2200 * Flush the input buffer. Called when the line discipline is
2201 * being closed, when the tty layer wants the buffer flushed (eg
2202 * at hangup).
2203 */
2204
2205static void gsmld_flush_buffer(struct tty_struct *tty)
2206{
2207}
2208
2209/**
2210 * gsmld_close - close the ldisc for this tty
2211 * @tty: device
2212 *
2213 * Called from the terminal layer when this line discipline is
2214 * being shut down, either because of a close or becsuse of a
2215 * discipline change. The function will not be called while other
2216 * ldisc methods are in progress.
2217 */
2218
2219static void gsmld_close(struct tty_struct *tty)
2220{
2221 struct gsm_mux *gsm = tty->disc_data;
2222
2223 gsmld_detach_gsm(tty, gsm);
2224
2225 gsmld_flush_buffer(tty);
2226 /* Do other clean up here */
2227 gsm_free_mux(gsm);
2228}
2229
2230/**
2231 * gsmld_open - open an ldisc
2232 * @tty: terminal to open
2233 *
2234 * Called when this line discipline is being attached to the
2235 * terminal device. Can sleep. Called serialized so that no
2236 * other events will occur in parallel. No further open will occur
2237 * until a close.
2238 */
2239
2240static int gsmld_open(struct tty_struct *tty)
2241{
2242 struct gsm_mux *gsm;
2243
2244 if (tty->ops->write == NULL)
2245 return -EINVAL;
2246
2247 /* Attach our ldisc data */
2248 gsm = gsm_alloc_mux();
2249 if (gsm == NULL)
2250 return -ENOMEM;
2251
2252 tty->disc_data = gsm;
2253 tty->receive_room = 65536;
2254
2255 /* Attach the initial passive connection */
2256 gsm->encoding = 1;
2257 return gsmld_attach_gsm(tty, gsm);
2258}
2259
2260/**
2261 * gsmld_write_wakeup - asynchronous I/O notifier
2262 * @tty: tty device
2263 *
2264 * Required for the ptys, serial driver etc. since processes
2265 * that attach themselves to the master and rely on ASYNC
2266 * IO must be woken up
2267 */
2268
2269static void gsmld_write_wakeup(struct tty_struct *tty)
2270{
2271 struct gsm_mux *gsm = tty->disc_data;
2272 unsigned long flags;
2273
2274 /* Queue poll */
2275 clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2276 gsm_data_kick(gsm);
2277 if (gsm->tx_bytes < TX_THRESH_LO) {
2278 spin_lock_irqsave(&gsm->tx_lock, flags);
2279 gsm_dlci_data_sweep(gsm);
2280 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2281 }
2282}
2283
2284/**
2285 * gsmld_read - read function for tty
2286 * @tty: tty device
2287 * @file: file object
2288 * @buf: userspace buffer pointer
2289 * @nr: size of I/O
2290 *
2291 * Perform reads for the line discipline. We are guaranteed that the
2292 * line discipline will not be closed under us but we may get multiple
2293 * parallel readers and must handle this ourselves. We may also get
2294 * a hangup. Always called in user context, may sleep.
2295 *
2296 * This code must be sure never to sleep through a hangup.
2297 */
2298
2299static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2300 unsigned char __user *buf, size_t nr)
2301{
2302 return -EOPNOTSUPP;
2303}
2304
2305/**
2306 * gsmld_write - write function for tty
2307 * @tty: tty device
2308 * @file: file object
2309 * @buf: userspace buffer pointer
2310 * @nr: size of I/O
2311 *
2312 * Called when the owner of the device wants to send a frame
2313 * itself (or some other control data). The data is transferred
2314 * as-is and must be properly framed and checksummed as appropriate
2315 * by userspace. Frames are either sent whole or not at all as this
2316 * avoids pain user side.
2317 */
2318
2319static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2320 const unsigned char *buf, size_t nr)
2321{
2322 int space = tty_write_room(tty);
2323 if (space >= nr)
2324 return tty->ops->write(tty, buf, nr);
2325 set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2326 return -ENOBUFS;
2327}
2328
2329/**
2330 * gsmld_poll - poll method for N_GSM0710
2331 * @tty: terminal device
2332 * @file: file accessing it
2333 * @wait: poll table
2334 *
2335 * Called when the line discipline is asked to poll() for data or
2336 * for special events. This code is not serialized with respect to
2337 * other events save open/close.
2338 *
2339 * This code must be sure never to sleep through a hangup.
2340 * Called without the kernel lock held - fine
2341 */
2342
2343static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2344 poll_table *wait)
2345{
2346 unsigned int mask = 0;
2347 struct gsm_mux *gsm = tty->disc_data;
2348
2349 poll_wait(file, &tty->read_wait, wait);
2350 poll_wait(file, &tty->write_wait, wait);
2351 if (tty_hung_up_p(file))
2352 mask |= POLLHUP;
2353 if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2354 mask |= POLLOUT | POLLWRNORM;
2355 if (gsm->dead)
2356 mask |= POLLHUP;
2357 return mask;
2358}
2359
2360static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2361 struct gsm_config *c)
2362{
2363 int need_close = 0;
2364 int need_restart = 0;
2365
2366 /* Stuff we don't support yet - UI or I frame transport, windowing */
2367 if ((c->adaption != 1 && c->adaption != 2) || c->k)
2368 return -EOPNOTSUPP;
2369 /* Check the MRU/MTU range looks sane */
2370 if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2371 return -EINVAL;
2372 if (c->n2 < 3)
2373 return -EINVAL;
2374 if (c->encapsulation > 1) /* Basic, advanced, no I */
2375 return -EINVAL;
2376 if (c->initiator > 1)
2377 return -EINVAL;
2378 if (c->i == 0 || c->i > 2) /* UIH and UI only */
2379 return -EINVAL;
2380 /*
2381 * See what is needed for reconfiguration
2382 */
2383
2384 /* Timing fields */
2385 if (c->t1 != 0 && c->t1 != gsm->t1)
2386 need_restart = 1;
2387 if (c->t2 != 0 && c->t2 != gsm->t2)
2388 need_restart = 1;
2389 if (c->encapsulation != gsm->encoding)
2390 need_restart = 1;
2391 if (c->adaption != gsm->adaption)
2392 need_restart = 1;
2393 /* Requires care */
2394 if (c->initiator != gsm->initiator)
2395 need_close = 1;
2396 if (c->mru != gsm->mru)
2397 need_restart = 1;
2398 if (c->mtu != gsm->mtu)
2399 need_restart = 1;
2400
2401 /*
2402 * Close down what is needed, restart and initiate the new
2403 * configuration
2404 */
2405
2406 if (need_close || need_restart) {
2407 gsm_dlci_begin_close(gsm->dlci[0]);
2408 /* This will timeout if the link is down due to N2 expiring */
2409 wait_event_interruptible(gsm->event,
2410 gsm->dlci[0]->state == DLCI_CLOSED);
2411 if (signal_pending(current))
2412 return -EINTR;
2413 }
2414 if (need_restart)
2415 gsm_cleanup_mux(gsm);
2416
2417 gsm->initiator = c->initiator;
2418 gsm->mru = c->mru;
2419 gsm->mtu = c->mtu;
2420 gsm->encoding = c->encapsulation;
2421 gsm->adaption = c->adaption;
2422 gsm->n2 = c->n2;
2423
2424 if (c->i == 1)
2425 gsm->ftype = UIH;
2426 else if (c->i == 2)
2427 gsm->ftype = UI;
2428
2429 if (c->t1)
2430 gsm->t1 = c->t1;
2431 if (c->t2)
2432 gsm->t2 = c->t2;
2433
2434 /* FIXME: We need to separate activation/deactivation from adding
2435 and removing from the mux array */
2436 if (need_restart)
2437 gsm_activate_mux(gsm);
2438 if (gsm->initiator && need_close)
2439 gsm_dlci_begin_open(gsm->dlci[0]);
2440 return 0;
2441}
2442
2443static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2444 unsigned int cmd, unsigned long arg)
2445{
2446 struct gsm_config c;
2447 struct gsm_mux *gsm = tty->disc_data;
2448
2449 switch (cmd) {
2450 case GSMIOC_GETCONF:
2451 memset(&c, 0, sizeof(c));
2452 c.adaption = gsm->adaption;
2453 c.encapsulation = gsm->encoding;
2454 c.initiator = gsm->initiator;
2455 c.t1 = gsm->t1;
2456 c.t2 = gsm->t2;
2457 c.t3 = 0; /* Not supported */
2458 c.n2 = gsm->n2;
2459 if (gsm->ftype == UIH)
2460 c.i = 1;
2461 else
2462 c.i = 2;
2463 pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
2464 c.mru = gsm->mru;
2465 c.mtu = gsm->mtu;
2466 c.k = 0;
2467 if (copy_to_user((void *)arg, &c, sizeof(c)))
2468 return -EFAULT;
2469 return 0;
2470 case GSMIOC_SETCONF:
2471 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2472 return -EFAULT;
2473 return gsmld_config(tty, gsm, &c);
2474 default:
2475 return n_tty_ioctl_helper(tty, file, cmd, arg);
2476 }
2477}
2478
2479
2480/* Line discipline for real tty */
2481struct tty_ldisc_ops tty_ldisc_packet = {
2482 .owner = THIS_MODULE,
2483 .magic = TTY_LDISC_MAGIC,
2484 .name = "n_gsm",
2485 .open = gsmld_open,
2486 .close = gsmld_close,
2487 .flush_buffer = gsmld_flush_buffer,
2488 .chars_in_buffer = gsmld_chars_in_buffer,
2489 .read = gsmld_read,
2490 .write = gsmld_write,
2491 .ioctl = gsmld_ioctl,
2492 .poll = gsmld_poll,
2493 .receive_buf = gsmld_receive_buf,
2494 .write_wakeup = gsmld_write_wakeup
2495};
2496
2497/*
2498 * Virtual tty side
2499 */
2500
2501#define TX_SIZE 512
2502
2503static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2504{
2505 u8 modembits[5];
2506 struct gsm_control *ctrl;
2507 int len = 2;
2508
2509 if (brk)
2510 len++;
2511
2512 modembits[0] = len << 1 | EA; /* Data bytes */
2513 modembits[1] = dlci->addr << 2 | 3; /* DLCI, EA, 1 */
2514 modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2515 if (brk)
2516 modembits[3] = brk << 4 | 2 | EA; /* Valid, EA */
2517 ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2518 if (ctrl == NULL)
2519 return -ENOMEM;
2520 return gsm_control_wait(dlci->gsm, ctrl);
2521}
2522
2523static int gsm_carrier_raised(struct tty_port *port)
2524{
2525 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2526 /* Not yet open so no carrier info */
2527 if (dlci->state != DLCI_OPEN)
2528 return 0;
2529 if (debug & 2)
2530 return 1;
2531 return dlci->modem_rx & TIOCM_CD;
2532}
2533
2534static void gsm_dtr_rts(struct tty_port *port, int onoff)
2535{
2536 struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2537 unsigned int modem_tx = dlci->modem_tx;
2538 if (onoff)
2539 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2540 else
2541 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2542 if (modem_tx != dlci->modem_tx) {
2543 dlci->modem_tx = modem_tx;
2544 gsmtty_modem_update(dlci, 0);
2545 }
2546}
2547
2548static const struct tty_port_operations gsm_port_ops = {
2549 .carrier_raised = gsm_carrier_raised,
2550 .dtr_rts = gsm_dtr_rts,
2551};
2552
2553
2554static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2555{
2556 struct gsm_mux *gsm;
2557 struct gsm_dlci *dlci;
2558 struct tty_port *port;
2559 unsigned int line = tty->index;
2560 unsigned int mux = line >> 6;
2561
2562 line = line & 0x3F;
2563
2564 if (mux >= MAX_MUX)
2565 return -ENXIO;
2566 /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2567 if (gsm_mux[mux] == NULL)
2568 return -EUNATCH;
2569 if (line == 0 || line > 61) /* 62/63 reserved */
2570 return -ECHRNG;
2571 gsm = gsm_mux[mux];
2572 if (gsm->dead)
2573 return -EL2HLT;
2574 dlci = gsm->dlci[line];
2575 if (dlci == NULL)
2576 dlci = gsm_dlci_alloc(gsm, line);
2577 if (dlci == NULL)
2578 return -ENOMEM;
2579 port = &dlci->port;
2580 port->count++;
2581 tty->driver_data = dlci;
2582 tty_port_tty_set(port, tty);
2583
2584 dlci->modem_rx = 0;
2585 /* We could in theory open and close before we wait - eg if we get
2586 a DM straight back. This is ok as that will have caused a hangup */
2587 set_bit(ASYNCB_INITIALIZED, &port->flags);
2588 /* Start sending off SABM messages */
2589 gsm_dlci_begin_open(dlci);
2590 /* And wait for virtual carrier */
2591 return tty_port_block_til_ready(port, tty, filp);
2592}
2593
2594static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2595{
2596 struct gsm_dlci *dlci = tty->driver_data;
2597 if (dlci == NULL)
2598 return;
2599 if (tty_port_close_start(&dlci->port, tty, filp) == 0)
2600 return;
2601 gsm_dlci_begin_close(dlci);
2602 tty_port_close_end(&dlci->port, tty);
2603 tty_port_tty_set(&dlci->port, NULL);
2604}
2605
2606static void gsmtty_hangup(struct tty_struct *tty)
2607{
2608 struct gsm_dlci *dlci = tty->driver_data;
2609 tty_port_hangup(&dlci->port);
2610 gsm_dlci_begin_close(dlci);
2611}
2612
2613static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2614 int len)
2615{
2616 struct gsm_dlci *dlci = tty->driver_data;
2617 /* Stuff the bytes into the fifo queue */
2618 int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
2619 /* Need to kick the channel */
2620 gsm_dlci_data_kick(dlci);
2621 return sent;
2622}
2623
2624static int gsmtty_write_room(struct tty_struct *tty)
2625{
2626 struct gsm_dlci *dlci = tty->driver_data;
2627 return TX_SIZE - kfifo_len(dlci->fifo);
2628}
2629
2630static int gsmtty_chars_in_buffer(struct tty_struct *tty)
2631{
2632 struct gsm_dlci *dlci = tty->driver_data;
2633 return kfifo_len(dlci->fifo);
2634}
2635
2636static void gsmtty_flush_buffer(struct tty_struct *tty)
2637{
2638 struct gsm_dlci *dlci = tty->driver_data;
2639 /* Caution needed: If we implement reliable transport classes
2640 then the data being transmitted can't simply be junked once
2641 it has first hit the stack. Until then we can just blow it
2642 away */
2643 kfifo_reset(dlci->fifo);
2644 /* Need to unhook this DLCI from the transmit queue logic */
2645}
2646
2647static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
2648{
2649 /* The FIFO handles the queue so the kernel will do the right
2650 thing waiting on chars_in_buffer before calling us. No work
2651 to do here */
2652}
2653
2654static int gsmtty_tiocmget(struct tty_struct *tty)
2655{
2656 struct gsm_dlci *dlci = tty->driver_data;
2657 return dlci->modem_rx;
2658}
2659
2660static int gsmtty_tiocmset(struct tty_struct *tty,
2661 unsigned int set, unsigned int clear)
2662{
2663 struct gsm_dlci *dlci = tty->driver_data;
2664 unsigned int modem_tx = dlci->modem_tx;
2665
2666 modem_tx &= clear;
2667 modem_tx |= set;
2668
2669 if (modem_tx != dlci->modem_tx) {
2670 dlci->modem_tx = modem_tx;
2671 return gsmtty_modem_update(dlci, 0);
2672 }
2673 return 0;
2674}
2675
2676
2677static int gsmtty_ioctl(struct tty_struct *tty,
2678 unsigned int cmd, unsigned long arg)
2679{
2680 return -ENOIOCTLCMD;
2681}
2682
2683static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
2684{
2685 /* For the moment its fixed. In actual fact the speed information
2686 for the virtual channel can be propogated in both directions by
2687 the RPN control message. This however rapidly gets nasty as we
2688 then have to remap modem signals each way according to whether
2689 our virtual cable is null modem etc .. */
2690 tty_termios_copy_hw(tty->termios, old);
2691}
2692
2693static void gsmtty_throttle(struct tty_struct *tty)
2694{
2695 struct gsm_dlci *dlci = tty->driver_data;
2696 if (tty->termios->c_cflag & CRTSCTS)
2697 dlci->modem_tx &= ~TIOCM_DTR;
2698 dlci->throttled = 1;
2699 /* Send an MSC with DTR cleared */
2700 gsmtty_modem_update(dlci, 0);
2701}
2702
2703static void gsmtty_unthrottle(struct tty_struct *tty)
2704{
2705 struct gsm_dlci *dlci = tty->driver_data;
2706 if (tty->termios->c_cflag & CRTSCTS)
2707 dlci->modem_tx |= TIOCM_DTR;
2708 dlci->throttled = 0;
2709 /* Send an MSC with DTR set */
2710 gsmtty_modem_update(dlci, 0);
2711}
2712
2713static int gsmtty_break_ctl(struct tty_struct *tty, int state)
2714{
2715 struct gsm_dlci *dlci = tty->driver_data;
2716 int encode = 0; /* Off */
2717
2718 if (state == -1) /* "On indefinitely" - we can't encode this
2719 properly */
2720 encode = 0x0F;
2721 else if (state > 0) {
2722 encode = state / 200; /* mS to encoding */
2723 if (encode > 0x0F)
2724 encode = 0x0F; /* Best effort */
2725 }
2726 return gsmtty_modem_update(dlci, encode);
2727}
2728
2729static struct tty_driver *gsm_tty_driver;
2730
2731/* Virtual ttys for the demux */
2732static const struct tty_operations gsmtty_ops = {
2733 .open = gsmtty_open,
2734 .close = gsmtty_close,
2735 .write = gsmtty_write,
2736 .write_room = gsmtty_write_room,
2737 .chars_in_buffer = gsmtty_chars_in_buffer,
2738 .flush_buffer = gsmtty_flush_buffer,
2739 .ioctl = gsmtty_ioctl,
2740 .throttle = gsmtty_throttle,
2741 .unthrottle = gsmtty_unthrottle,
2742 .set_termios = gsmtty_set_termios,
2743 .hangup = gsmtty_hangup,
2744 .wait_until_sent = gsmtty_wait_until_sent,
2745 .tiocmget = gsmtty_tiocmget,
2746 .tiocmset = gsmtty_tiocmset,
2747 .break_ctl = gsmtty_break_ctl,
2748};
2749
2750
2751
2752static int __init gsm_init(void)
2753{
2754 /* Fill in our line protocol discipline, and register it */
2755 int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
2756 if (status != 0) {
2757 pr_err("n_gsm: can't register line discipline (err = %d)\n",
2758 status);
2759 return status;
2760 }
2761
2762 gsm_tty_driver = alloc_tty_driver(256);
2763 if (!gsm_tty_driver) {
2764 tty_unregister_ldisc(N_GSM0710);
2765 pr_err("gsm_init: tty allocation failed.\n");
2766 return -EINVAL;
2767 }
2768 gsm_tty_driver->owner = THIS_MODULE;
2769 gsm_tty_driver->driver_name = "gsmtty";
2770 gsm_tty_driver->name = "gsmtty";
2771 gsm_tty_driver->major = 0; /* Dynamic */
2772 gsm_tty_driver->minor_start = 0;
2773 gsm_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
2774 gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
2775 gsm_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
2776 | TTY_DRIVER_HARDWARE_BREAK;
2777 gsm_tty_driver->init_termios = tty_std_termios;
2778 /* Fixme */
2779 gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
2780 tty_set_operations(gsm_tty_driver, &gsmtty_ops);
2781
2782 spin_lock_init(&gsm_mux_lock);
2783
2784 if (tty_register_driver(gsm_tty_driver)) {
2785 put_tty_driver(gsm_tty_driver);
2786 tty_unregister_ldisc(N_GSM0710);
2787 pr_err("gsm_init: tty registration failed.\n");
2788 return -EBUSY;
2789 }
2790 pr_debug("gsm_init: loaded as %d,%d.\n",
2791 gsm_tty_driver->major, gsm_tty_driver->minor_start);
2792 return 0;
2793}
2794
2795static void __exit gsm_exit(void)
2796{
2797 int status = tty_unregister_ldisc(N_GSM0710);
2798 if (status != 0)
2799 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
2800 status);
2801 tty_unregister_driver(gsm_tty_driver);
2802 put_tty_driver(gsm_tty_driver);
2803}
2804
2805module_init(gsm_init);
2806module_exit(gsm_exit);
2807
2808
2809MODULE_LICENSE("GPL");
2810MODULE_ALIAS_LDISC(N_GSM0710);
generated by cgit v1.2.2 (git 2.25.0) at 2025-04-26 04:31:38 -0400