Revert "tty: make receive_buf() return the amout of bytes received"
[linux-2.6.git] / drivers / tty / n_gsm.c
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
63 static int debug;
64 module_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
89 struct 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
108 struct 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
151 struct 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
169 struct 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 */
250 static struct gsm_mux *gsm_mux[MAX_MUX];        /* GSM muxes */
251 static 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
301 static const struct tty_port_operations gsm_port_ops;
302
303 /*
304  *      CRC table for GSM 0710
305  */
306
307 static 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
354 static 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
369 static 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
385 static 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
402 static 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
432 static 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
513 static 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
543 static 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
590 static 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
604 static 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
625 static 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
650 static 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
705 static 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
760 static 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
780 static 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
830 static 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, skb_pull(dlci->skb, len), len);
879         __gsm_data_queue(dlci, msg);
880         if (last)
881                 dlci->skb = NULL;
882         return size;
883 }
884
885 /**
886  *      gsm_dlci_data_sweep             -       look for data to send
887  *      @gsm: the GSM mux
888  *
889  *      Sweep the GSM mux channels in priority order looking for ones with
890  *      data to send. We could do with optimising this scan a bit. We aim
891  *      to fill the queue totally or up to TX_THRESH_HI bytes. Once we hit
892  *      TX_THRESH_LO we get called again
893  *
894  *      FIXME: We should round robin between groups and in theory you can
895  *      renegotiate DLCI priorities with optional stuff. Needs optimising.
896  */
897
898 static void gsm_dlci_data_sweep(struct gsm_mux *gsm)
899 {
900         int len;
901         /* Priority ordering: We should do priority with RR of the groups */
902         int i = 1;
903
904         while (i < NUM_DLCI) {
905                 struct gsm_dlci *dlci;
906
907                 if (gsm->tx_bytes > TX_THRESH_HI)
908                         break;
909                 dlci = gsm->dlci[i];
910                 if (dlci == NULL || dlci->constipated) {
911                         i++;
912                         continue;
913                 }
914                 if (dlci->adaption < 3)
915                         len = gsm_dlci_data_output(gsm, dlci);
916                 else
917                         len = gsm_dlci_data_output_framed(gsm, dlci);
918                 if (len < 0)
919                         break;
920                 /* DLCI empty - try the next */
921                 if (len == 0)
922                         i++;
923         }
924 }
925
926 /**
927  *      gsm_dlci_data_kick      -       transmit if possible
928  *      @dlci: DLCI to kick
929  *
930  *      Transmit data from this DLCI if the queue is empty. We can't rely on
931  *      a tty wakeup except when we filled the pipe so we need to fire off
932  *      new data ourselves in other cases.
933  */
934
935 static void gsm_dlci_data_kick(struct gsm_dlci *dlci)
936 {
937         unsigned long flags;
938
939         spin_lock_irqsave(&dlci->gsm->tx_lock, flags);
940         /* If we have nothing running then we need to fire up */
941         if (dlci->gsm->tx_bytes == 0)
942                 gsm_dlci_data_output(dlci->gsm, dlci);
943         else if (dlci->gsm->tx_bytes < TX_THRESH_LO)
944                 gsm_dlci_data_sweep(dlci->gsm);
945         spin_unlock_irqrestore(&dlci->gsm->tx_lock, flags);
946 }
947
948 /*
949  *      Control message processing
950  */
951
952
953 /**
954  *      gsm_control_reply       -       send a response frame to a control
955  *      @gsm: gsm channel
956  *      @cmd: the command to use
957  *      @data: data to follow encoded info
958  *      @dlen: length of data
959  *
960  *      Encode up and queue a UI/UIH frame containing our response.
961  */
962
963 static void gsm_control_reply(struct gsm_mux *gsm, int cmd, u8 *data,
964                                         int dlen)
965 {
966         struct gsm_msg *msg;
967         msg = gsm_data_alloc(gsm, 0, dlen + 2, gsm->ftype);
968         if (msg == NULL)
969                 return;
970         msg->data[0] = (cmd & 0xFE) << 1 | EA;  /* Clear C/R */
971         msg->data[1] = (dlen << 1) | EA;
972         memcpy(msg->data + 2, data, dlen);
973         gsm_data_queue(gsm->dlci[0], msg);
974 }
975
976 /**
977  *      gsm_process_modem       -       process received modem status
978  *      @tty: virtual tty bound to the DLCI
979  *      @dlci: DLCI to affect
980  *      @modem: modem bits (full EA)
981  *
982  *      Used when a modem control message or line state inline in adaption
983  *      layer 2 is processed. Sort out the local modem state and throttles
984  */
985
986 static void gsm_process_modem(struct tty_struct *tty, struct gsm_dlci *dlci,
987                                                         u32 modem)
988 {
989         int  mlines = 0;
990         u8 brk = modem >> 6;
991
992         /* Flow control/ready to communicate */
993         if (modem & MDM_FC) {
994                 /* Need to throttle our output on this device */
995                 dlci->constipated = 1;
996         }
997         if (modem & MDM_RTC) {
998                 mlines |= TIOCM_DSR | TIOCM_DTR;
999                 dlci->constipated = 0;
1000                 gsm_dlci_data_kick(dlci);
1001         }
1002         /* Map modem bits */
1003         if (modem & MDM_RTR)
1004                 mlines |= TIOCM_RTS | TIOCM_CTS;
1005         if (modem & MDM_IC)
1006                 mlines |= TIOCM_RI;
1007         if (modem & MDM_DV)
1008                 mlines |= TIOCM_CD;
1009
1010         /* Carrier drop -> hangup */
1011         if (tty) {
1012                 if ((mlines & TIOCM_CD) == 0 && (dlci->modem_rx & TIOCM_CD))
1013                         if (!(tty->termios->c_cflag & CLOCAL))
1014                                 tty_hangup(tty);
1015                 if (brk & 0x01)
1016                         tty_insert_flip_char(tty, 0, TTY_BREAK);
1017         }
1018         dlci->modem_rx = mlines;
1019 }
1020
1021 /**
1022  *      gsm_control_modem       -       modem status received
1023  *      @gsm: GSM channel
1024  *      @data: data following command
1025  *      @clen: command length
1026  *
1027  *      We have received a modem status control message. This is used by
1028  *      the GSM mux protocol to pass virtual modem line status and optionally
1029  *      to indicate break signals. Unpack it, convert to Linux representation
1030  *      and if need be stuff a break message down the tty.
1031  */
1032
1033 static void gsm_control_modem(struct gsm_mux *gsm, u8 *data, int clen)
1034 {
1035         unsigned int addr = 0;
1036         unsigned int modem = 0;
1037         struct gsm_dlci *dlci;
1038         int len = clen;
1039         u8 *dp = data;
1040         struct tty_struct *tty;
1041
1042         while (gsm_read_ea(&addr, *dp++) == 0) {
1043                 len--;
1044                 if (len == 0)
1045                         return;
1046         }
1047         /* Must be at least one byte following the EA */
1048         len--;
1049         if (len <= 0)
1050                 return;
1051
1052         addr >>= 1;
1053         /* Closed port, or invalid ? */
1054         if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1055                 return;
1056         dlci = gsm->dlci[addr];
1057
1058         while (gsm_read_ea(&modem, *dp++) == 0) {
1059                 len--;
1060                 if (len == 0)
1061                         return;
1062         }
1063         tty = tty_port_tty_get(&dlci->port);
1064         gsm_process_modem(tty, dlci, modem);
1065         if (tty) {
1066                 tty_wakeup(tty);
1067                 tty_kref_put(tty);
1068         }
1069         gsm_control_reply(gsm, CMD_MSC, data, clen);
1070 }
1071
1072 /**
1073  *      gsm_control_rls         -       remote line status
1074  *      @gsm: GSM channel
1075  *      @data: data bytes
1076  *      @clen: data length
1077  *
1078  *      The modem sends us a two byte message on the control channel whenever
1079  *      it wishes to send us an error state from the virtual link. Stuff
1080  *      this into the uplink tty if present
1081  */
1082
1083 static void gsm_control_rls(struct gsm_mux *gsm, u8 *data, int clen)
1084 {
1085         struct tty_struct *tty;
1086         unsigned int addr = 0 ;
1087         u8 bits;
1088         int len = clen;
1089         u8 *dp = data;
1090
1091         while (gsm_read_ea(&addr, *dp++) == 0) {
1092                 len--;
1093                 if (len == 0)
1094                         return;
1095         }
1096         /* Must be at least one byte following ea */
1097         len--;
1098         if (len <= 0)
1099                 return;
1100         addr >>= 1;
1101         /* Closed port, or invalid ? */
1102         if (addr == 0 || addr >= NUM_DLCI || gsm->dlci[addr] == NULL)
1103                 return;
1104         /* No error ? */
1105         bits = *dp;
1106         if ((bits & 1) == 0)
1107                 return;
1108         /* See if we have an uplink tty */
1109         tty = tty_port_tty_get(&gsm->dlci[addr]->port);
1110
1111         if (tty) {
1112                 if (bits & 2)
1113                         tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1114                 if (bits & 4)
1115                         tty_insert_flip_char(tty, 0, TTY_PARITY);
1116                 if (bits & 8)
1117                         tty_insert_flip_char(tty, 0, TTY_FRAME);
1118                 tty_flip_buffer_push(tty);
1119                 tty_kref_put(tty);
1120         }
1121         gsm_control_reply(gsm, CMD_RLS, data, clen);
1122 }
1123
1124 static void gsm_dlci_begin_close(struct gsm_dlci *dlci);
1125
1126 /**
1127  *      gsm_control_message     -       DLCI 0 control processing
1128  *      @gsm: our GSM mux
1129  *      @command:  the command EA
1130  *      @data: data beyond the command/length EAs
1131  *      @clen: length
1132  *
1133  *      Input processor for control messages from the other end of the link.
1134  *      Processes the incoming request and queues a response frame or an
1135  *      NSC response if not supported
1136  */
1137
1138 static void gsm_control_message(struct gsm_mux *gsm, unsigned int command,
1139                                                         u8 *data, int clen)
1140 {
1141         u8 buf[1];
1142         switch (command) {
1143         case CMD_CLD: {
1144                 struct gsm_dlci *dlci = gsm->dlci[0];
1145                 /* Modem wishes to close down */
1146                 if (dlci) {
1147                         dlci->dead = 1;
1148                         gsm->dead = 1;
1149                         gsm_dlci_begin_close(dlci);
1150                 }
1151                 }
1152                 break;
1153         case CMD_TEST:
1154                 /* Modem wishes to test, reply with the data */
1155                 gsm_control_reply(gsm, CMD_TEST, data, clen);
1156                 break;
1157         case CMD_FCON:
1158                 /* Modem wants us to STFU */
1159                 gsm->constipated = 1;
1160                 gsm_control_reply(gsm, CMD_FCON, NULL, 0);
1161                 break;
1162         case CMD_FCOFF:
1163                 /* Modem can accept data again */
1164                 gsm->constipated = 0;
1165                 gsm_control_reply(gsm, CMD_FCOFF, NULL, 0);
1166                 /* Kick the link in case it is idling */
1167                 gsm_data_kick(gsm);
1168                 break;
1169         case CMD_MSC:
1170                 /* Out of band modem line change indicator for a DLCI */
1171                 gsm_control_modem(gsm, data, clen);
1172                 break;
1173         case CMD_RLS:
1174                 /* Out of band error reception for a DLCI */
1175                 gsm_control_rls(gsm, data, clen);
1176                 break;
1177         case CMD_PSC:
1178                 /* Modem wishes to enter power saving state */
1179                 gsm_control_reply(gsm, CMD_PSC, NULL, 0);
1180                 break;
1181                 /* Optional unsupported commands */
1182         case CMD_PN:    /* Parameter negotiation */
1183         case CMD_RPN:   /* Remote port negotiation */
1184         case CMD_SNC:   /* Service negotiation command */
1185         default:
1186                 /* Reply to bad commands with an NSC */
1187                 buf[0] = command;
1188                 gsm_control_reply(gsm, CMD_NSC, buf, 1);
1189                 break;
1190         }
1191 }
1192
1193 /**
1194  *      gsm_control_response    -       process a response to our control
1195  *      @gsm: our GSM mux
1196  *      @command: the command (response) EA
1197  *      @data: data beyond the command/length EA
1198  *      @clen: length
1199  *
1200  *      Process a response to an outstanding command. We only allow a single
1201  *      control message in flight so this is fairly easy. All the clean up
1202  *      is done by the caller, we just update the fields, flag it as done
1203  *      and return
1204  */
1205
1206 static void gsm_control_response(struct gsm_mux *gsm, unsigned int command,
1207                                                         u8 *data, int clen)
1208 {
1209         struct gsm_control *ctrl;
1210         unsigned long flags;
1211
1212         spin_lock_irqsave(&gsm->control_lock, flags);
1213
1214         ctrl = gsm->pending_cmd;
1215         /* Does the reply match our command */
1216         command |= 1;
1217         if (ctrl != NULL && (command == ctrl->cmd || command == CMD_NSC)) {
1218                 /* Our command was replied to, kill the retry timer */
1219                 del_timer(&gsm->t2_timer);
1220                 gsm->pending_cmd = NULL;
1221                 /* Rejected by the other end */
1222                 if (command == CMD_NSC)
1223                         ctrl->error = -EOPNOTSUPP;
1224                 ctrl->done = 1;
1225                 wake_up(&gsm->event);
1226         }
1227         spin_unlock_irqrestore(&gsm->control_lock, flags);
1228 }
1229
1230 /**
1231  *      gsm_control_transmit    -       send control packet
1232  *      @gsm: gsm mux
1233  *      @ctrl: frame to send
1234  *
1235  *      Send out a pending control command (called under control lock)
1236  */
1237
1238 static void gsm_control_transmit(struct gsm_mux *gsm, struct gsm_control *ctrl)
1239 {
1240         struct gsm_msg *msg = gsm_data_alloc(gsm, 0, ctrl->len + 1, gsm->ftype);
1241         if (msg == NULL)
1242                 return;
1243         msg->data[0] = (ctrl->cmd << 1) | 2 | EA;       /* command */
1244         memcpy(msg->data + 1, ctrl->data, ctrl->len);
1245         gsm_data_queue(gsm->dlci[0], msg);
1246 }
1247
1248 /**
1249  *      gsm_control_retransmit  -       retransmit a control frame
1250  *      @data: pointer to our gsm object
1251  *
1252  *      Called off the T2 timer expiry in order to retransmit control frames
1253  *      that have been lost in the system somewhere. The control_lock protects
1254  *      us from colliding with another sender or a receive completion event.
1255  *      In that situation the timer may still occur in a small window but
1256  *      gsm->pending_cmd will be NULL and we just let the timer expire.
1257  */
1258
1259 static void gsm_control_retransmit(unsigned long data)
1260 {
1261         struct gsm_mux *gsm = (struct gsm_mux *)data;
1262         struct gsm_control *ctrl;
1263         unsigned long flags;
1264         spin_lock_irqsave(&gsm->control_lock, flags);
1265         ctrl = gsm->pending_cmd;
1266         if (ctrl) {
1267                 gsm->cretries--;
1268                 if (gsm->cretries == 0) {
1269                         gsm->pending_cmd = NULL;
1270                         ctrl->error = -ETIMEDOUT;
1271                         ctrl->done = 1;
1272                         spin_unlock_irqrestore(&gsm->control_lock, flags);
1273                         wake_up(&gsm->event);
1274                         return;
1275                 }
1276                 gsm_control_transmit(gsm, ctrl);
1277                 mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1278         }
1279         spin_unlock_irqrestore(&gsm->control_lock, flags);
1280 }
1281
1282 /**
1283  *      gsm_control_send        -       send a control frame on DLCI 0
1284  *      @gsm: the GSM channel
1285  *      @command: command  to send including CR bit
1286  *      @data: bytes of data (must be kmalloced)
1287  *      @len: length of the block to send
1288  *
1289  *      Queue and dispatch a control command. Only one command can be
1290  *      active at a time. In theory more can be outstanding but the matching
1291  *      gets really complicated so for now stick to one outstanding.
1292  */
1293
1294 static struct gsm_control *gsm_control_send(struct gsm_mux *gsm,
1295                 unsigned int command, u8 *data, int clen)
1296 {
1297         struct gsm_control *ctrl = kzalloc(sizeof(struct gsm_control),
1298                                                 GFP_KERNEL);
1299         unsigned long flags;
1300         if (ctrl == NULL)
1301                 return NULL;
1302 retry:
1303         wait_event(gsm->event, gsm->pending_cmd == NULL);
1304         spin_lock_irqsave(&gsm->control_lock, flags);
1305         if (gsm->pending_cmd != NULL) {
1306                 spin_unlock_irqrestore(&gsm->control_lock, flags);
1307                 goto retry;
1308         }
1309         ctrl->cmd = command;
1310         ctrl->data = data;
1311         ctrl->len = clen;
1312         gsm->pending_cmd = ctrl;
1313         gsm->cretries = gsm->n2;
1314         mod_timer(&gsm->t2_timer, jiffies + gsm->t2 * HZ / 100);
1315         gsm_control_transmit(gsm, ctrl);
1316         spin_unlock_irqrestore(&gsm->control_lock, flags);
1317         return ctrl;
1318 }
1319
1320 /**
1321  *      gsm_control_wait        -       wait for a control to finish
1322  *      @gsm: GSM mux
1323  *      @control: control we are waiting on
1324  *
1325  *      Waits for the control to complete or time out. Frees any used
1326  *      resources and returns 0 for success, or an error if the remote
1327  *      rejected or ignored the request.
1328  */
1329
1330 static int gsm_control_wait(struct gsm_mux *gsm, struct gsm_control *control)
1331 {
1332         int err;
1333         wait_event(gsm->event, control->done == 1);
1334         err = control->error;
1335         kfree(control);
1336         return err;
1337 }
1338
1339
1340 /*
1341  *      DLCI level handling: Needs krefs
1342  */
1343
1344 /*
1345  *      State transitions and timers
1346  */
1347
1348 /**
1349  *      gsm_dlci_close          -       a DLCI has closed
1350  *      @dlci: DLCI that closed
1351  *
1352  *      Perform processing when moving a DLCI into closed state. If there
1353  *      is an attached tty this is hung up
1354  */
1355
1356 static void gsm_dlci_close(struct gsm_dlci *dlci)
1357 {
1358         del_timer(&dlci->t1);
1359         if (debug & 8)
1360                 pr_debug("DLCI %d goes closed.\n", dlci->addr);
1361         dlci->state = DLCI_CLOSED;
1362         if (dlci->addr != 0) {
1363                 struct tty_struct  *tty = tty_port_tty_get(&dlci->port);
1364                 if (tty) {
1365                         tty_hangup(tty);
1366                         tty_kref_put(tty);
1367                 }
1368                 kfifo_reset(dlci->fifo);
1369         } else
1370                 dlci->gsm->dead = 1;
1371         wake_up(&dlci->gsm->event);
1372         /* A DLCI 0 close is a MUX termination so we need to kick that
1373            back to userspace somehow */
1374 }
1375
1376 /**
1377  *      gsm_dlci_open           -       a DLCI has opened
1378  *      @dlci: DLCI that opened
1379  *
1380  *      Perform processing when moving a DLCI into open state.
1381  */
1382
1383 static void gsm_dlci_open(struct gsm_dlci *dlci)
1384 {
1385         /* Note that SABM UA .. SABM UA first UA lost can mean that we go
1386            open -> open */
1387         del_timer(&dlci->t1);
1388         /* This will let a tty open continue */
1389         dlci->state = DLCI_OPEN;
1390         if (debug & 8)
1391                 pr_debug("DLCI %d goes open.\n", dlci->addr);
1392         wake_up(&dlci->gsm->event);
1393 }
1394
1395 /**
1396  *      gsm_dlci_t1             -       T1 timer expiry
1397  *      @dlci: DLCI that opened
1398  *
1399  *      The T1 timer handles retransmits of control frames (essentially of
1400  *      SABM and DISC). We resend the command until the retry count runs out
1401  *      in which case an opening port goes back to closed and a closing port
1402  *      is simply put into closed state (any further frames from the other
1403  *      end will get a DM response)
1404  */
1405
1406 static void gsm_dlci_t1(unsigned long data)
1407 {
1408         struct gsm_dlci *dlci = (struct gsm_dlci *)data;
1409         struct gsm_mux *gsm = dlci->gsm;
1410
1411         switch (dlci->state) {
1412         case DLCI_OPENING:
1413                 dlci->retries--;
1414                 if (dlci->retries) {
1415                         gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1416                         mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1417                 } else
1418                         gsm_dlci_close(dlci);
1419                 break;
1420         case DLCI_CLOSING:
1421                 dlci->retries--;
1422                 if (dlci->retries) {
1423                         gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1424                         mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1425                 } else
1426                         gsm_dlci_close(dlci);
1427                 break;
1428         }
1429 }
1430
1431 /**
1432  *      gsm_dlci_begin_open     -       start channel open procedure
1433  *      @dlci: DLCI to open
1434  *
1435  *      Commence opening a DLCI from the Linux side. We issue SABM messages
1436  *      to the modem which should then reply with a UA, at which point we
1437  *      will move into open state. Opening is done asynchronously with retry
1438  *      running off timers and the responses.
1439  */
1440
1441 static void gsm_dlci_begin_open(struct gsm_dlci *dlci)
1442 {
1443         struct gsm_mux *gsm = dlci->gsm;
1444         if (dlci->state == DLCI_OPEN || dlci->state == DLCI_OPENING)
1445                 return;
1446         dlci->retries = gsm->n2;
1447         dlci->state = DLCI_OPENING;
1448         gsm_command(dlci->gsm, dlci->addr, SABM|PF);
1449         mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1450 }
1451
1452 /**
1453  *      gsm_dlci_begin_close    -       start channel open procedure
1454  *      @dlci: DLCI to open
1455  *
1456  *      Commence closing a DLCI from the Linux side. We issue DISC messages
1457  *      to the modem which should then reply with a UA, at which point we
1458  *      will move into closed state. Closing is done asynchronously with retry
1459  *      off timers. We may also receive a DM reply from the other end which
1460  *      indicates the channel was already closed.
1461  */
1462
1463 static void gsm_dlci_begin_close(struct gsm_dlci *dlci)
1464 {
1465         struct gsm_mux *gsm = dlci->gsm;
1466         if (dlci->state == DLCI_CLOSED || dlci->state == DLCI_CLOSING)
1467                 return;
1468         dlci->retries = gsm->n2;
1469         dlci->state = DLCI_CLOSING;
1470         gsm_command(dlci->gsm, dlci->addr, DISC|PF);
1471         mod_timer(&dlci->t1, jiffies + gsm->t1 * HZ / 100);
1472 }
1473
1474 /**
1475  *      gsm_dlci_data           -       data arrived
1476  *      @dlci: channel
1477  *      @data: block of bytes received
1478  *      @len: length of received block
1479  *
1480  *      A UI or UIH frame has arrived which contains data for a channel
1481  *      other than the control channel. If the relevant virtual tty is
1482  *      open we shovel the bits down it, if not we drop them.
1483  */
1484
1485 static void gsm_dlci_data(struct gsm_dlci *dlci, u8 *data, int len)
1486 {
1487         /* krefs .. */
1488         struct tty_port *port = &dlci->port;
1489         struct tty_struct *tty = tty_port_tty_get(port);
1490         unsigned int modem = 0;
1491
1492         if (debug & 16)
1493                 pr_debug("%d bytes for tty %p\n", len, tty);
1494         if (tty) {
1495                 switch (dlci->adaption)  {
1496                 /* Unsupported types */
1497                 /* Packetised interruptible data */
1498                 case 4:
1499                         break;
1500                 /* Packetised uininterruptible voice/data */
1501                 case 3:
1502                         break;
1503                 /* Asynchronous serial with line state in each frame */
1504                 case 2:
1505                         while (gsm_read_ea(&modem, *data++) == 0) {
1506                                 len--;
1507                                 if (len == 0)
1508                                         return;
1509                         }
1510                         gsm_process_modem(tty, dlci, modem);
1511                 /* Line state will go via DLCI 0 controls only */
1512                 case 1:
1513                 default:
1514                         tty_insert_flip_string(tty, data, len);
1515                         tty_flip_buffer_push(tty);
1516                 }
1517                 tty_kref_put(tty);
1518         }
1519 }
1520
1521 /**
1522  *      gsm_dlci_control        -       data arrived on control channel
1523  *      @dlci: channel
1524  *      @data: block of bytes received
1525  *      @len: length of received block
1526  *
1527  *      A UI or UIH frame has arrived which contains data for DLCI 0 the
1528  *      control channel. This should contain a command EA followed by
1529  *      control data bytes. The command EA contains a command/response bit
1530  *      and we divide up the work accordingly.
1531  */
1532
1533 static void gsm_dlci_command(struct gsm_dlci *dlci, u8 *data, int len)
1534 {
1535         /* See what command is involved */
1536         unsigned int command = 0;
1537         while (len-- > 0) {
1538                 if (gsm_read_ea(&command, *data++) == 1) {
1539                         int clen = *data++;
1540                         len--;
1541                         /* FIXME: this is properly an EA */
1542                         clen >>= 1;
1543                         /* Malformed command ? */
1544                         if (clen > len)
1545                                 return;
1546                         if (command & 1)
1547                                 gsm_control_message(dlci->gsm, command,
1548                                                                 data, clen);
1549                         else
1550                                 gsm_control_response(dlci->gsm, command,
1551                                                                 data, clen);
1552                         return;
1553                 }
1554         }
1555 }
1556
1557 /*
1558  *      Allocate/Free DLCI channels
1559  */
1560
1561 /**
1562  *      gsm_dlci_alloc          -       allocate a DLCI
1563  *      @gsm: GSM mux
1564  *      @addr: address of the DLCI
1565  *
1566  *      Allocate and install a new DLCI object into the GSM mux.
1567  *
1568  *      FIXME: review locking races
1569  */
1570
1571 static struct gsm_dlci *gsm_dlci_alloc(struct gsm_mux *gsm, int addr)
1572 {
1573         struct gsm_dlci *dlci = kzalloc(sizeof(struct gsm_dlci), GFP_ATOMIC);
1574         if (dlci == NULL)
1575                 return NULL;
1576         spin_lock_init(&dlci->lock);
1577         dlci->fifo = &dlci->_fifo;
1578         if (kfifo_alloc(&dlci->_fifo, 4096, GFP_KERNEL) < 0) {
1579                 kfree(dlci);
1580                 return NULL;
1581         }
1582
1583         skb_queue_head_init(&dlci->skb_list);
1584         init_timer(&dlci->t1);
1585         dlci->t1.function = gsm_dlci_t1;
1586         dlci->t1.data = (unsigned long)dlci;
1587         tty_port_init(&dlci->port);
1588         dlci->port.ops = &gsm_port_ops;
1589         dlci->gsm = gsm;
1590         dlci->addr = addr;
1591         dlci->adaption = gsm->adaption;
1592         dlci->state = DLCI_CLOSED;
1593         if (addr)
1594                 dlci->data = gsm_dlci_data;
1595         else
1596                 dlci->data = gsm_dlci_command;
1597         gsm->dlci[addr] = dlci;
1598         return dlci;
1599 }
1600
1601 /**
1602  *      gsm_dlci_free           -       release DLCI
1603  *      @dlci: DLCI to destroy
1604  *
1605  *      Free up a DLCI. Currently to keep the lifetime rules sane we only
1606  *      clean up DLCI objects when the MUX closes rather than as the port
1607  *      is closed down on both the tty and mux levels.
1608  *
1609  *      Can sleep.
1610  */
1611 static void gsm_dlci_free(struct gsm_dlci *dlci)
1612 {
1613         struct tty_struct *tty = tty_port_tty_get(&dlci->port);
1614         if (tty) {
1615                 tty_vhangup(tty);
1616                 tty_kref_put(tty);
1617         }
1618         del_timer_sync(&dlci->t1);
1619         dlci->gsm->dlci[dlci->addr] = NULL;
1620         kfifo_free(dlci->fifo);
1621         kfree(dlci);
1622 }
1623
1624 /*
1625  *      LAPBish link layer logic
1626  */
1627
1628 /**
1629  *      gsm_queue               -       a GSM frame is ready to process
1630  *      @gsm: pointer to our gsm mux
1631  *
1632  *      At this point in time a frame has arrived and been demangled from
1633  *      the line encoding. All the differences between the encodings have
1634  *      been handled below us and the frame is unpacked into the structures.
1635  *      The fcs holds the header FCS but any data FCS must be added here.
1636  */
1637
1638 static void gsm_queue(struct gsm_mux *gsm)
1639 {
1640         struct gsm_dlci *dlci;
1641         u8 cr;
1642         int address;
1643         /* We have to sneak a look at the packet body to do the FCS.
1644            A somewhat layering violation in the spec */
1645
1646         if ((gsm->control & ~PF) == UI)
1647                 gsm->fcs = gsm_fcs_add_block(gsm->fcs, gsm->buf, gsm->len);
1648         if (gsm->encoding == 0){
1649                 /* WARNING: gsm->received_fcs is used for gsm->encoding = 0 only.
1650                             In this case it contain the last piece of data
1651                             required to generate final CRC */
1652                 gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->received_fcs);
1653         }
1654         if (gsm->fcs != GOOD_FCS) {
1655                 gsm->bad_fcs++;
1656                 if (debug & 4)
1657                         pr_debug("BAD FCS %02x\n", gsm->fcs);
1658                 return;
1659         }
1660         address = gsm->address >> 1;
1661         if (address >= NUM_DLCI)
1662                 goto invalid;
1663
1664         cr = gsm->address & 1;          /* C/R bit */
1665
1666         gsm_print_packet("<--", address, cr, gsm->control, gsm->buf, gsm->len);
1667
1668         cr ^= 1 - gsm->initiator;       /* Flip so 1 always means command */
1669         dlci = gsm->dlci[address];
1670
1671         switch (gsm->control) {
1672         case SABM|PF:
1673                 if (cr == 0)
1674                         goto invalid;
1675                 if (dlci == NULL)
1676                         dlci = gsm_dlci_alloc(gsm, address);
1677                 if (dlci == NULL)
1678                         return;
1679                 if (dlci->dead)
1680                         gsm_response(gsm, address, DM);
1681                 else {
1682                         gsm_response(gsm, address, UA);
1683                         gsm_dlci_open(dlci);
1684                 }
1685                 break;
1686         case DISC|PF:
1687                 if (cr == 0)
1688                         goto invalid;
1689                 if (dlci == NULL || dlci->state == DLCI_CLOSED) {
1690                         gsm_response(gsm, address, DM);
1691                         return;
1692                 }
1693                 /* Real close complete */
1694                 gsm_response(gsm, address, UA);
1695                 gsm_dlci_close(dlci);
1696                 break;
1697         case UA:
1698         case UA|PF:
1699                 if (cr == 0 || dlci == NULL)
1700                         break;
1701                 switch (dlci->state) {
1702                 case DLCI_CLOSING:
1703                         gsm_dlci_close(dlci);
1704                         break;
1705                 case DLCI_OPENING:
1706                         gsm_dlci_open(dlci);
1707                         break;
1708                 }
1709                 break;
1710         case DM:        /* DM can be valid unsolicited */
1711         case DM|PF:
1712                 if (cr)
1713                         goto invalid;
1714                 if (dlci == NULL)
1715                         return;
1716                 gsm_dlci_close(dlci);
1717                 break;
1718         case UI:
1719         case UI|PF:
1720         case UIH:
1721         case UIH|PF:
1722 #if 0
1723                 if (cr)
1724                         goto invalid;
1725 #endif
1726                 if (dlci == NULL || dlci->state != DLCI_OPEN) {
1727                         gsm_command(gsm, address, DM|PF);
1728                         return;
1729                 }
1730                 dlci->data(dlci, gsm->buf, gsm->len);
1731                 break;
1732         default:
1733                 goto invalid;
1734         }
1735         return;
1736 invalid:
1737         gsm->malformed++;
1738         return;
1739 }
1740
1741
1742 /**
1743  *      gsm0_receive    -       perform processing for non-transparency
1744  *      @gsm: gsm data for this ldisc instance
1745  *      @c: character
1746  *
1747  *      Receive bytes in gsm mode 0
1748  */
1749
1750 static void gsm0_receive(struct gsm_mux *gsm, unsigned char c)
1751 {
1752         unsigned int len;
1753
1754         switch (gsm->state) {
1755         case GSM_SEARCH:        /* SOF marker */
1756                 if (c == GSM0_SOF) {
1757                         gsm->state = GSM_ADDRESS;
1758                         gsm->address = 0;
1759                         gsm->len = 0;
1760                         gsm->fcs = INIT_FCS;
1761                 }
1762                 break;
1763         case GSM_ADDRESS:       /* Address EA */
1764                 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1765                 if (gsm_read_ea(&gsm->address, c))
1766                         gsm->state = GSM_CONTROL;
1767                 break;
1768         case GSM_CONTROL:       /* Control Byte */
1769                 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1770                 gsm->control = c;
1771                 gsm->state = GSM_LEN0;
1772                 break;
1773         case GSM_LEN0:          /* Length EA */
1774                 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1775                 if (gsm_read_ea(&gsm->len, c)) {
1776                         if (gsm->len > gsm->mru) {
1777                                 gsm->bad_size++;
1778                                 gsm->state = GSM_SEARCH;
1779                                 break;
1780                         }
1781                         gsm->count = 0;
1782                         if (!gsm->len)
1783                                 gsm->state = GSM_FCS;
1784                         else
1785                                 gsm->state = GSM_DATA;
1786                         break;
1787                 }
1788                 gsm->state = GSM_LEN1;
1789                 break;
1790         case GSM_LEN1:
1791                 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1792                 len = c;
1793                 gsm->len |= len << 7;
1794                 if (gsm->len > gsm->mru) {
1795                         gsm->bad_size++;
1796                         gsm->state = GSM_SEARCH;
1797                         break;
1798                 }
1799                 gsm->count = 0;
1800                 if (!gsm->len)
1801                         gsm->state = GSM_FCS;
1802                 else
1803                         gsm->state = GSM_DATA;
1804                 break;
1805         case GSM_DATA:          /* Data */
1806                 gsm->buf[gsm->count++] = c;
1807                 if (gsm->count == gsm->len)
1808                         gsm->state = GSM_FCS;
1809                 break;
1810         case GSM_FCS:           /* FCS follows the packet */
1811                 gsm->received_fcs = c;
1812                 if (c == GSM0_SOF) {
1813                         gsm->state = GSM_SEARCH;
1814                         break;
1815                 }
1816                 gsm_queue(gsm);
1817                 gsm->state = GSM_SSOF;
1818                 break;
1819         case GSM_SSOF:
1820                 if (c == GSM0_SOF) {
1821                         gsm->state = GSM_SEARCH;
1822                         break;
1823                 }
1824                 break;
1825         }
1826 }
1827
1828 /**
1829  *      gsm1_receive    -       perform processing for non-transparency
1830  *      @gsm: gsm data for this ldisc instance
1831  *      @c: character
1832  *
1833  *      Receive bytes in mode 1 (Advanced option)
1834  */
1835
1836 static void gsm1_receive(struct gsm_mux *gsm, unsigned char c)
1837 {
1838         if (c == GSM1_SOF) {
1839                 /* EOF is only valid in frame if we have got to the data state
1840                    and received at least one byte (the FCS) */
1841                 if (gsm->state == GSM_DATA && gsm->count) {
1842                         /* Extract the FCS */
1843                         gsm->count--;
1844                         gsm->fcs = gsm_fcs_add(gsm->fcs, gsm->buf[gsm->count]);
1845                         gsm->len = gsm->count;
1846                         gsm_queue(gsm);
1847                         gsm->state  = GSM_START;
1848                         return;
1849                 }
1850                 /* Any partial frame was a runt so go back to start */
1851                 if (gsm->state != GSM_START) {
1852                         gsm->malformed++;
1853                         gsm->state = GSM_START;
1854                 }
1855                 /* A SOF in GSM_START means we are still reading idling or
1856                    framing bytes */
1857                 return;
1858         }
1859
1860         if (c == GSM1_ESCAPE) {
1861                 gsm->escape = 1;
1862                 return;
1863         }
1864
1865         /* Only an unescaped SOF gets us out of GSM search */
1866         if (gsm->state == GSM_SEARCH)
1867                 return;
1868
1869         if (gsm->escape) {
1870                 c ^= GSM1_ESCAPE_BITS;
1871                 gsm->escape = 0;
1872         }
1873         switch (gsm->state) {
1874         case GSM_START:         /* First byte after SOF */
1875                 gsm->address = 0;
1876                 gsm->state = GSM_ADDRESS;
1877                 gsm->fcs = INIT_FCS;
1878                 /* Drop through */
1879         case GSM_ADDRESS:       /* Address continuation */
1880                 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1881                 if (gsm_read_ea(&gsm->address, c))
1882                         gsm->state = GSM_CONTROL;
1883                 break;
1884         case GSM_CONTROL:       /* Control Byte */
1885                 gsm->fcs = gsm_fcs_add(gsm->fcs, c);
1886                 gsm->control = c;
1887                 gsm->count = 0;
1888                 gsm->state = GSM_DATA;
1889                 break;
1890         case GSM_DATA:          /* Data */
1891                 if (gsm->count > gsm->mru) {    /* Allow one for the FCS */
1892                         gsm->state = GSM_OVERRUN;
1893                         gsm->bad_size++;
1894                 } else
1895                         gsm->buf[gsm->count++] = c;
1896                 break;
1897         case GSM_OVERRUN:       /* Over-long - eg a dropped SOF */
1898                 break;
1899         }
1900 }
1901
1902 /**
1903  *      gsm_error               -       handle tty error
1904  *      @gsm: ldisc data
1905  *      @data: byte received (may be invalid)
1906  *      @flag: error received
1907  *
1908  *      Handle an error in the receipt of data for a frame. Currently we just
1909  *      go back to hunting for a SOF.
1910  *
1911  *      FIXME: better diagnostics ?
1912  */
1913
1914 static void gsm_error(struct gsm_mux *gsm,
1915                                 unsigned char data, unsigned char flag)
1916 {
1917         gsm->state = GSM_SEARCH;
1918         gsm->io_error++;
1919 }
1920
1921 /**
1922  *      gsm_cleanup_mux         -       generic GSM protocol cleanup
1923  *      @gsm: our mux
1924  *
1925  *      Clean up the bits of the mux which are the same for all framing
1926  *      protocols. Remove the mux from the mux table, stop all the timers
1927  *      and then shut down each device hanging up the channels as we go.
1928  */
1929
1930 void gsm_cleanup_mux(struct gsm_mux *gsm)
1931 {
1932         int i;
1933         struct gsm_dlci *dlci = gsm->dlci[0];
1934         struct gsm_msg *txq;
1935
1936         gsm->dead = 1;
1937
1938         spin_lock(&gsm_mux_lock);
1939         for (i = 0; i < MAX_MUX; i++) {
1940                 if (gsm_mux[i] == gsm) {
1941                         gsm_mux[i] = NULL;
1942                         break;
1943                 }
1944         }
1945         spin_unlock(&gsm_mux_lock);
1946         WARN_ON(i == MAX_MUX);
1947
1948         del_timer_sync(&gsm->t2_timer);
1949         /* Now we are sure T2 has stopped */
1950         if (dlci) {
1951                 dlci->dead = 1;
1952                 gsm_dlci_begin_close(dlci);
1953                 wait_event_interruptible(gsm->event,
1954                                         dlci->state == DLCI_CLOSED);
1955         }
1956         /* Free up any link layer users */
1957         for (i = 0; i < NUM_DLCI; i++)
1958                 if (gsm->dlci[i])
1959                         gsm_dlci_free(gsm->dlci[i]);
1960         /* Now wipe the queues */
1961         for (txq = gsm->tx_head; txq != NULL; txq = gsm->tx_head) {
1962                 gsm->tx_head = txq->next;
1963                 kfree(txq);
1964         }
1965         gsm->tx_tail = NULL;
1966 }
1967 EXPORT_SYMBOL_GPL(gsm_cleanup_mux);
1968
1969 /**
1970  *      gsm_activate_mux        -       generic GSM setup
1971  *      @gsm: our mux
1972  *
1973  *      Set up the bits of the mux which are the same for all framing
1974  *      protocols. Add the mux to the mux table so it can be opened and
1975  *      finally kick off connecting to DLCI 0 on the modem.
1976  */
1977
1978 int gsm_activate_mux(struct gsm_mux *gsm)
1979 {
1980         struct gsm_dlci *dlci;
1981         int i = 0;
1982
1983         init_timer(&gsm->t2_timer);
1984         gsm->t2_timer.function = gsm_control_retransmit;
1985         gsm->t2_timer.data = (unsigned long)gsm;
1986         init_waitqueue_head(&gsm->event);
1987         spin_lock_init(&gsm->control_lock);
1988         spin_lock_init(&gsm->tx_lock);
1989
1990         if (gsm->encoding == 0)
1991                 gsm->receive = gsm0_receive;
1992         else
1993                 gsm->receive = gsm1_receive;
1994         gsm->error = gsm_error;
1995
1996         spin_lock(&gsm_mux_lock);
1997         for (i = 0; i < MAX_MUX; i++) {
1998                 if (gsm_mux[i] == NULL) {
1999                         gsm_mux[i] = gsm;
2000                         break;
2001                 }
2002         }
2003         spin_unlock(&gsm_mux_lock);
2004         if (i == MAX_MUX)
2005                 return -EBUSY;
2006
2007         dlci = gsm_dlci_alloc(gsm, 0);
2008         if (dlci == NULL)
2009                 return -ENOMEM;
2010         gsm->dead = 0;          /* Tty opens are now permissible */
2011         return 0;
2012 }
2013 EXPORT_SYMBOL_GPL(gsm_activate_mux);
2014
2015 /**
2016  *      gsm_free_mux            -       free up a mux
2017  *      @mux: mux to free
2018  *
2019  *      Dispose of allocated resources for a dead mux. No refcounting
2020  *      at present so the mux must be truly dead.
2021  */
2022 void gsm_free_mux(struct gsm_mux *gsm)
2023 {
2024         kfree(gsm->txframe);
2025         kfree(gsm->buf);
2026         kfree(gsm);
2027 }
2028 EXPORT_SYMBOL_GPL(gsm_free_mux);
2029
2030 /**
2031  *      gsm_alloc_mux           -       allocate a mux
2032  *
2033  *      Creates a new mux ready for activation.
2034  */
2035
2036 struct gsm_mux *gsm_alloc_mux(void)
2037 {
2038         struct gsm_mux *gsm = kzalloc(sizeof(struct gsm_mux), GFP_KERNEL);
2039         if (gsm == NULL)
2040                 return NULL;
2041         gsm->buf = kmalloc(MAX_MRU + 1, GFP_KERNEL);
2042         if (gsm->buf == NULL) {
2043                 kfree(gsm);
2044                 return NULL;
2045         }
2046         gsm->txframe = kmalloc(2 * MAX_MRU + 2, GFP_KERNEL);
2047         if (gsm->txframe == NULL) {
2048                 kfree(gsm->buf);
2049                 kfree(gsm);
2050                 return NULL;
2051         }
2052         spin_lock_init(&gsm->lock);
2053
2054         gsm->t1 = T1;
2055         gsm->t2 = T2;
2056         gsm->n2 = N2;
2057         gsm->ftype = UIH;
2058         gsm->initiator = 0;
2059         gsm->adaption = 1;
2060         gsm->encoding = 1;
2061         gsm->mru = 64;  /* Default to encoding 1 so these should be 64 */
2062         gsm->mtu = 64;
2063         gsm->dead = 1;  /* Avoid early tty opens */
2064
2065         return gsm;
2066 }
2067 EXPORT_SYMBOL_GPL(gsm_alloc_mux);
2068
2069 /**
2070  *      gsmld_output            -       write to link
2071  *      @gsm: our mux
2072  *      @data: bytes to output
2073  *      @len: size
2074  *
2075  *      Write a block of data from the GSM mux to the data channel. This
2076  *      will eventually be serialized from above but at the moment isn't.
2077  */
2078
2079 static int gsmld_output(struct gsm_mux *gsm, u8 *data, int len)
2080 {
2081         if (tty_write_room(gsm->tty) < len) {
2082                 set_bit(TTY_DO_WRITE_WAKEUP, &gsm->tty->flags);
2083                 return -ENOSPC;
2084         }
2085         if (debug & 4)
2086                 print_hex_dump_bytes("gsmld_output: ", DUMP_PREFIX_OFFSET,
2087                                      data, len);
2088         gsm->tty->ops->write(gsm->tty, data, len);
2089         return len;
2090 }
2091
2092 /**
2093  *      gsmld_attach_gsm        -       mode set up
2094  *      @tty: our tty structure
2095  *      @gsm: our mux
2096  *
2097  *      Set up the MUX for basic mode and commence connecting to the
2098  *      modem. Currently called from the line discipline set up but
2099  *      will need moving to an ioctl path.
2100  */
2101
2102 static int gsmld_attach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2103 {
2104         int ret;
2105
2106         gsm->tty = tty_kref_get(tty);
2107         gsm->output = gsmld_output;
2108         ret =  gsm_activate_mux(gsm);
2109         if (ret != 0)
2110                 tty_kref_put(gsm->tty);
2111         return ret;
2112 }
2113
2114
2115 /**
2116  *      gsmld_detach_gsm        -       stop doing 0710 mux
2117  *      @tty: tty attached to the mux
2118  *      @gsm: mux
2119  *
2120  *      Shutdown and then clean up the resources used by the line discipline
2121  */
2122
2123 static void gsmld_detach_gsm(struct tty_struct *tty, struct gsm_mux *gsm)
2124 {
2125         WARN_ON(tty != gsm->tty);
2126         gsm_cleanup_mux(gsm);
2127         tty_kref_put(gsm->tty);
2128         gsm->tty = NULL;
2129 }
2130
2131 static void gsmld_receive_buf(struct tty_struct *tty, const unsigned char *cp,
2132                               char *fp, int count)
2133 {
2134         struct gsm_mux *gsm = tty->disc_data;
2135         const unsigned char *dp;
2136         char *f;
2137         int i;
2138         char buf[64];
2139         char flags;
2140
2141         if (debug & 4)
2142                 print_hex_dump_bytes("gsmld_receive: ", DUMP_PREFIX_OFFSET,
2143                                      cp, count);
2144
2145         for (i = count, dp = cp, f = fp; i; i--, dp++) {
2146                 flags = *f++;
2147                 switch (flags) {
2148                 case TTY_NORMAL:
2149                         gsm->receive(gsm, *dp);
2150                         break;
2151                 case TTY_OVERRUN:
2152                 case TTY_BREAK:
2153                 case TTY_PARITY:
2154                 case TTY_FRAME:
2155                         gsm->error(gsm, *dp, flags);
2156                         break;
2157                 default:
2158                         WARN_ONCE("%s: unknown flag %d\n",
2159                                tty_name(tty, buf), flags);
2160                         break;
2161                 }
2162         }
2163         /* FASYNC if needed ? */
2164         /* If clogged call tty_throttle(tty); */
2165 }
2166
2167 /**
2168  *      gsmld_chars_in_buffer   -       report available bytes
2169  *      @tty: tty device
2170  *
2171  *      Report the number of characters buffered to be delivered to user
2172  *      at this instant in time.
2173  *
2174  *      Locking: gsm lock
2175  */
2176
2177 static ssize_t gsmld_chars_in_buffer(struct tty_struct *tty)
2178 {
2179         return 0;
2180 }
2181
2182 /**
2183  *      gsmld_flush_buffer      -       clean input queue
2184  *      @tty:   terminal device
2185  *
2186  *      Flush the input buffer. Called when the line discipline is
2187  *      being closed, when the tty layer wants the buffer flushed (eg
2188  *      at hangup).
2189  */
2190
2191 static void gsmld_flush_buffer(struct tty_struct *tty)
2192 {
2193 }
2194
2195 /**
2196  *      gsmld_close             -       close the ldisc for this tty
2197  *      @tty: device
2198  *
2199  *      Called from the terminal layer when this line discipline is
2200  *      being shut down, either because of a close or becsuse of a
2201  *      discipline change. The function will not be called while other
2202  *      ldisc methods are in progress.
2203  */
2204
2205 static void gsmld_close(struct tty_struct *tty)
2206 {
2207         struct gsm_mux *gsm = tty->disc_data;
2208
2209         gsmld_detach_gsm(tty, gsm);
2210
2211         gsmld_flush_buffer(tty);
2212         /* Do other clean up here */
2213         gsm_free_mux(gsm);
2214 }
2215
2216 /**
2217  *      gsmld_open              -       open an ldisc
2218  *      @tty: terminal to open
2219  *
2220  *      Called when this line discipline is being attached to the
2221  *      terminal device. Can sleep. Called serialized so that no
2222  *      other events will occur in parallel. No further open will occur
2223  *      until a close.
2224  */
2225
2226 static int gsmld_open(struct tty_struct *tty)
2227 {
2228         struct gsm_mux *gsm;
2229
2230         if (tty->ops->write == NULL)
2231                 return -EINVAL;
2232
2233         /* Attach our ldisc data */
2234         gsm = gsm_alloc_mux();
2235         if (gsm == NULL)
2236                 return -ENOMEM;
2237
2238         tty->disc_data = gsm;
2239         tty->receive_room = 65536;
2240
2241         /* Attach the initial passive connection */
2242         gsm->encoding = 1;
2243         return gsmld_attach_gsm(tty, gsm);
2244 }
2245
2246 /**
2247  *      gsmld_write_wakeup      -       asynchronous I/O notifier
2248  *      @tty: tty device
2249  *
2250  *      Required for the ptys, serial driver etc. since processes
2251  *      that attach themselves to the master and rely on ASYNC
2252  *      IO must be woken up
2253  */
2254
2255 static void gsmld_write_wakeup(struct tty_struct *tty)
2256 {
2257         struct gsm_mux *gsm = tty->disc_data;
2258         unsigned long flags;
2259
2260         /* Queue poll */
2261         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2262         gsm_data_kick(gsm);
2263         if (gsm->tx_bytes < TX_THRESH_LO) {
2264                 spin_lock_irqsave(&gsm->tx_lock, flags);
2265                 gsm_dlci_data_sweep(gsm);
2266                 spin_unlock_irqrestore(&gsm->tx_lock, flags);
2267         }
2268 }
2269
2270 /**
2271  *      gsmld_read              -       read function for tty
2272  *      @tty: tty device
2273  *      @file: file object
2274  *      @buf: userspace buffer pointer
2275  *      @nr: size of I/O
2276  *
2277  *      Perform reads for the line discipline. We are guaranteed that the
2278  *      line discipline will not be closed under us but we may get multiple
2279  *      parallel readers and must handle this ourselves. We may also get
2280  *      a hangup. Always called in user context, may sleep.
2281  *
2282  *      This code must be sure never to sleep through a hangup.
2283  */
2284
2285 static ssize_t gsmld_read(struct tty_struct *tty, struct file *file,
2286                          unsigned char __user *buf, size_t nr)
2287 {
2288         return -EOPNOTSUPP;
2289 }
2290
2291 /**
2292  *      gsmld_write             -       write function for tty
2293  *      @tty: tty device
2294  *      @file: file object
2295  *      @buf: userspace buffer pointer
2296  *      @nr: size of I/O
2297  *
2298  *      Called when the owner of the device wants to send a frame
2299  *      itself (or some other control data). The data is transferred
2300  *      as-is and must be properly framed and checksummed as appropriate
2301  *      by userspace. Frames are either sent whole or not at all as this
2302  *      avoids pain user side.
2303  */
2304
2305 static ssize_t gsmld_write(struct tty_struct *tty, struct file *file,
2306                            const unsigned char *buf, size_t nr)
2307 {
2308         int space = tty_write_room(tty);
2309         if (space >= nr)
2310                 return tty->ops->write(tty, buf, nr);
2311         set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
2312         return -ENOBUFS;
2313 }
2314
2315 /**
2316  *      gsmld_poll              -       poll method for N_GSM0710
2317  *      @tty: terminal device
2318  *      @file: file accessing it
2319  *      @wait: poll table
2320  *
2321  *      Called when the line discipline is asked to poll() for data or
2322  *      for special events. This code is not serialized with respect to
2323  *      other events save open/close.
2324  *
2325  *      This code must be sure never to sleep through a hangup.
2326  *      Called without the kernel lock held - fine
2327  */
2328
2329 static unsigned int gsmld_poll(struct tty_struct *tty, struct file *file,
2330                                                         poll_table *wait)
2331 {
2332         unsigned int mask = 0;
2333         struct gsm_mux *gsm = tty->disc_data;
2334
2335         poll_wait(file, &tty->read_wait, wait);
2336         poll_wait(file, &tty->write_wait, wait);
2337         if (tty_hung_up_p(file))
2338                 mask |= POLLHUP;
2339         if (!tty_is_writelocked(tty) && tty_write_room(tty) > 0)
2340                 mask |= POLLOUT | POLLWRNORM;
2341         if (gsm->dead)
2342                 mask |= POLLHUP;
2343         return mask;
2344 }
2345
2346 static int gsmld_config(struct tty_struct *tty, struct gsm_mux *gsm,
2347                                                         struct gsm_config *c)
2348 {
2349         int need_close = 0;
2350         int need_restart = 0;
2351
2352         /* Stuff we don't support yet - UI or I frame transport, windowing */
2353         if ((c->adaption != 1 && c->adaption != 2) || c->k)
2354                 return -EOPNOTSUPP;
2355         /* Check the MRU/MTU range looks sane */
2356         if (c->mru > MAX_MRU || c->mtu > MAX_MTU || c->mru < 8 || c->mtu < 8)
2357                 return -EINVAL;
2358         if (c->n2 < 3)
2359                 return -EINVAL;
2360         if (c->encapsulation > 1)       /* Basic, advanced, no I */
2361                 return -EINVAL;
2362         if (c->initiator > 1)
2363                 return -EINVAL;
2364         if (c->i == 0 || c->i > 2)      /* UIH and UI only */
2365                 return -EINVAL;
2366         /*
2367          *      See what is needed for reconfiguration
2368          */
2369
2370         /* Timing fields */
2371         if (c->t1 != 0 && c->t1 != gsm->t1)
2372                 need_restart = 1;
2373         if (c->t2 != 0 && c->t2 != gsm->t2)
2374                 need_restart = 1;
2375         if (c->encapsulation != gsm->encoding)
2376                 need_restart = 1;
2377         if (c->adaption != gsm->adaption)
2378                 need_restart = 1;
2379         /* Requires care */
2380         if (c->initiator != gsm->initiator)
2381                 need_close = 1;
2382         if (c->mru != gsm->mru)
2383                 need_restart = 1;
2384         if (c->mtu != gsm->mtu)
2385                 need_restart = 1;
2386
2387         /*
2388          *      Close down what is needed, restart and initiate the new
2389          *      configuration
2390          */
2391
2392         if (need_close || need_restart) {
2393                 gsm_dlci_begin_close(gsm->dlci[0]);
2394                 /* This will timeout if the link is down due to N2 expiring */
2395                 wait_event_interruptible(gsm->event,
2396                                 gsm->dlci[0]->state == DLCI_CLOSED);
2397                 if (signal_pending(current))
2398                         return -EINTR;
2399         }
2400         if (need_restart)
2401                 gsm_cleanup_mux(gsm);
2402
2403         gsm->initiator = c->initiator;
2404         gsm->mru = c->mru;
2405         gsm->mtu = c->mtu;
2406         gsm->encoding = c->encapsulation;
2407         gsm->adaption = c->adaption;
2408         gsm->n2 = c->n2;
2409
2410         if (c->i == 1)
2411                 gsm->ftype = UIH;
2412         else if (c->i == 2)
2413                 gsm->ftype = UI;
2414
2415         if (c->t1)
2416                 gsm->t1 = c->t1;
2417         if (c->t2)
2418                 gsm->t2 = c->t2;
2419
2420         /* FIXME: We need to separate activation/deactivation from adding
2421            and removing from the mux array */
2422         if (need_restart)
2423                 gsm_activate_mux(gsm);
2424         if (gsm->initiator && need_close)
2425                 gsm_dlci_begin_open(gsm->dlci[0]);
2426         return 0;
2427 }
2428
2429 static int gsmld_ioctl(struct tty_struct *tty, struct file *file,
2430                        unsigned int cmd, unsigned long arg)
2431 {
2432         struct gsm_config c;
2433         struct gsm_mux *gsm = tty->disc_data;
2434
2435         switch (cmd) {
2436         case GSMIOC_GETCONF:
2437                 memset(&c, 0, sizeof(c));
2438                 c.adaption = gsm->adaption;
2439                 c.encapsulation = gsm->encoding;
2440                 c.initiator = gsm->initiator;
2441                 c.t1 = gsm->t1;
2442                 c.t2 = gsm->t2;
2443                 c.t3 = 0;       /* Not supported */
2444                 c.n2 = gsm->n2;
2445                 if (gsm->ftype == UIH)
2446                         c.i = 1;
2447                 else
2448                         c.i = 2;
2449                 pr_debug("Ftype %d i %d\n", gsm->ftype, c.i);
2450                 c.mru = gsm->mru;
2451                 c.mtu = gsm->mtu;
2452                 c.k = 0;
2453                 if (copy_to_user((void *)arg, &c, sizeof(c)))
2454                         return -EFAULT;
2455                 return 0;
2456         case GSMIOC_SETCONF:
2457                 if (copy_from_user(&c, (void *)arg, sizeof(c)))
2458                         return -EFAULT;
2459                 return gsmld_config(tty, gsm, &c);
2460         default:
2461                 return n_tty_ioctl_helper(tty, file, cmd, arg);
2462         }
2463 }
2464
2465
2466 /* Line discipline for real tty */
2467 struct tty_ldisc_ops tty_ldisc_packet = {
2468         .owner           = THIS_MODULE,
2469         .magic           = TTY_LDISC_MAGIC,
2470         .name            = "n_gsm",
2471         .open            = gsmld_open,
2472         .close           = gsmld_close,
2473         .flush_buffer    = gsmld_flush_buffer,
2474         .chars_in_buffer = gsmld_chars_in_buffer,
2475         .read            = gsmld_read,
2476         .write           = gsmld_write,
2477         .ioctl           = gsmld_ioctl,
2478         .poll            = gsmld_poll,
2479         .receive_buf     = gsmld_receive_buf,
2480         .write_wakeup    = gsmld_write_wakeup
2481 };
2482
2483 /*
2484  *      Virtual tty side
2485  */
2486
2487 #define TX_SIZE         512
2488
2489 static int gsmtty_modem_update(struct gsm_dlci *dlci, u8 brk)
2490 {
2491         u8 modembits[5];
2492         struct gsm_control *ctrl;
2493         int len = 2;
2494
2495         if (brk)
2496                 len++;
2497
2498         modembits[0] = len << 1 | EA;           /* Data bytes */
2499         modembits[1] = dlci->addr << 2 | 3;     /* DLCI, EA, 1 */
2500         modembits[2] = gsm_encode_modem(dlci) << 1 | EA;
2501         if (brk)
2502                 modembits[3] = brk << 4 | 2 | EA;       /* Valid, EA */
2503         ctrl = gsm_control_send(dlci->gsm, CMD_MSC, modembits, len + 1);
2504         if (ctrl == NULL)
2505                 return -ENOMEM;
2506         return gsm_control_wait(dlci->gsm, ctrl);
2507 }
2508
2509 static int gsm_carrier_raised(struct tty_port *port)
2510 {
2511         struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2512         /* Not yet open so no carrier info */
2513         if (dlci->state != DLCI_OPEN)
2514                 return 0;
2515         if (debug & 2)
2516                 return 1;
2517         return dlci->modem_rx & TIOCM_CD;
2518 }
2519
2520 static void gsm_dtr_rts(struct tty_port *port, int onoff)
2521 {
2522         struct gsm_dlci *dlci = container_of(port, struct gsm_dlci, port);
2523         unsigned int modem_tx = dlci->modem_tx;
2524         if (onoff)
2525                 modem_tx |= TIOCM_DTR | TIOCM_RTS;
2526         else
2527                 modem_tx &= ~(TIOCM_DTR | TIOCM_RTS);
2528         if (modem_tx != dlci->modem_tx) {
2529                 dlci->modem_tx = modem_tx;
2530                 gsmtty_modem_update(dlci, 0);
2531         }
2532 }
2533
2534 static const struct tty_port_operations gsm_port_ops = {
2535         .carrier_raised = gsm_carrier_raised,
2536         .dtr_rts = gsm_dtr_rts,
2537 };
2538
2539
2540 static int gsmtty_open(struct tty_struct *tty, struct file *filp)
2541 {
2542         struct gsm_mux *gsm;
2543         struct gsm_dlci *dlci;
2544         struct tty_port *port;
2545         unsigned int line = tty->index;
2546         unsigned int mux = line >> 6;
2547
2548         line = line & 0x3F;
2549
2550         if (mux >= MAX_MUX)
2551                 return -ENXIO;
2552         /* FIXME: we need to lock gsm_mux for lifetimes of ttys eventually */
2553         if (gsm_mux[mux] == NULL)
2554                 return -EUNATCH;
2555         if (line == 0 || line > 61)     /* 62/63 reserved */
2556                 return -ECHRNG;
2557         gsm = gsm_mux[mux];
2558         if (gsm->dead)
2559                 return -EL2HLT;
2560         dlci = gsm->dlci[line];
2561         if (dlci == NULL)
2562                 dlci = gsm_dlci_alloc(gsm, line);
2563         if (dlci == NULL)
2564                 return -ENOMEM;
2565         port = &dlci->port;
2566         port->count++;
2567         tty->driver_data = dlci;
2568         tty_port_tty_set(port, tty);
2569
2570         dlci->modem_rx = 0;
2571         /* We could in theory open and close before we wait - eg if we get
2572            a DM straight back. This is ok as that will have caused a hangup */
2573         set_bit(ASYNCB_INITIALIZED, &port->flags);
2574         /* Start sending off SABM messages */
2575         gsm_dlci_begin_open(dlci);
2576         /* And wait for virtual carrier */
2577         return tty_port_block_til_ready(port, tty, filp);
2578 }
2579
2580 static void gsmtty_close(struct tty_struct *tty, struct file *filp)
2581 {
2582         struct gsm_dlci *dlci = tty->driver_data;
2583         if (dlci == NULL)
2584                 return;
2585         if (tty_port_close_start(&dlci->port, tty, filp) == 0)
2586                 return;
2587         gsm_dlci_begin_close(dlci);
2588         tty_port_close_end(&dlci->port, tty);
2589         tty_port_tty_set(&dlci->port, NULL);
2590 }
2591
2592 static void gsmtty_hangup(struct tty_struct *tty)
2593 {
2594         struct gsm_dlci *dlci = tty->driver_data;
2595         tty_port_hangup(&dlci->port);
2596         gsm_dlci_begin_close(dlci);
2597 }
2598
2599 static int gsmtty_write(struct tty_struct *tty, const unsigned char *buf,
2600                                                                     int len)
2601 {
2602         struct gsm_dlci *dlci = tty->driver_data;
2603         /* Stuff the bytes into the fifo queue */
2604         int sent = kfifo_in_locked(dlci->fifo, buf, len, &dlci->lock);
2605         /* Need to kick the channel */
2606         gsm_dlci_data_kick(dlci);
2607         return sent;
2608 }
2609
2610 static int gsmtty_write_room(struct tty_struct *tty)
2611 {
2612         struct gsm_dlci *dlci = tty->driver_data;
2613         return TX_SIZE - kfifo_len(dlci->fifo);
2614 }
2615
2616 static int gsmtty_chars_in_buffer(struct tty_struct *tty)
2617 {
2618         struct gsm_dlci *dlci = tty->driver_data;
2619         return kfifo_len(dlci->fifo);
2620 }
2621
2622 static void gsmtty_flush_buffer(struct tty_struct *tty)
2623 {
2624         struct gsm_dlci *dlci = tty->driver_data;
2625         /* Caution needed: If we implement reliable transport classes
2626            then the data being transmitted can't simply be junked once
2627            it has first hit the stack. Until then we can just blow it
2628            away */
2629         kfifo_reset(dlci->fifo);
2630         /* Need to unhook this DLCI from the transmit queue logic */
2631 }
2632
2633 static void gsmtty_wait_until_sent(struct tty_struct *tty, int timeout)
2634 {
2635         /* The FIFO handles the queue so the kernel will do the right
2636            thing waiting on chars_in_buffer before calling us. No work
2637            to do here */
2638 }
2639
2640 static int gsmtty_tiocmget(struct tty_struct *tty)
2641 {
2642         struct gsm_dlci *dlci = tty->driver_data;
2643         return dlci->modem_rx;
2644 }
2645
2646 static int gsmtty_tiocmset(struct tty_struct *tty,
2647         unsigned int set, unsigned int clear)
2648 {
2649         struct gsm_dlci *dlci = tty->driver_data;
2650         unsigned int modem_tx = dlci->modem_tx;
2651
2652         modem_tx &= clear;
2653         modem_tx |= set;
2654
2655         if (modem_tx != dlci->modem_tx) {
2656                 dlci->modem_tx = modem_tx;
2657                 return gsmtty_modem_update(dlci, 0);
2658         }
2659         return 0;
2660 }
2661
2662
2663 static int gsmtty_ioctl(struct tty_struct *tty,
2664                         unsigned int cmd, unsigned long arg)
2665 {
2666         return -ENOIOCTLCMD;
2667 }
2668
2669 static void gsmtty_set_termios(struct tty_struct *tty, struct ktermios *old)
2670 {
2671         /* For the moment its fixed. In actual fact the speed information
2672            for the virtual channel can be propogated in both directions by
2673            the RPN control message. This however rapidly gets nasty as we
2674            then have to remap modem signals each way according to whether
2675            our virtual cable is null modem etc .. */
2676         tty_termios_copy_hw(tty->termios, old);
2677 }
2678
2679 static void gsmtty_throttle(struct tty_struct *tty)
2680 {
2681         struct gsm_dlci *dlci = tty->driver_data;
2682         if (tty->termios->c_cflag & CRTSCTS)
2683                 dlci->modem_tx &= ~TIOCM_DTR;
2684         dlci->throttled = 1;
2685         /* Send an MSC with DTR cleared */
2686         gsmtty_modem_update(dlci, 0);
2687 }
2688
2689 static void gsmtty_unthrottle(struct tty_struct *tty)
2690 {
2691         struct gsm_dlci *dlci = tty->driver_data;
2692         if (tty->termios->c_cflag & CRTSCTS)
2693                 dlci->modem_tx |= TIOCM_DTR;
2694         dlci->throttled = 0;
2695         /* Send an MSC with DTR set */
2696         gsmtty_modem_update(dlci, 0);
2697 }
2698
2699 static int gsmtty_break_ctl(struct tty_struct *tty, int state)
2700 {
2701         struct gsm_dlci *dlci = tty->driver_data;
2702         int encode = 0; /* Off */
2703
2704         if (state == -1)        /* "On indefinitely" - we can't encode this
2705                                     properly */
2706                 encode = 0x0F;
2707         else if (state > 0) {
2708                 encode = state / 200;   /* mS to encoding */
2709                 if (encode > 0x0F)
2710                         encode = 0x0F;  /* Best effort */
2711         }
2712         return gsmtty_modem_update(dlci, encode);
2713 }
2714
2715 static struct tty_driver *gsm_tty_driver;
2716
2717 /* Virtual ttys for the demux */
2718 static const struct tty_operations gsmtty_ops = {
2719         .open                   = gsmtty_open,
2720         .close                  = gsmtty_close,
2721         .write                  = gsmtty_write,
2722         .write_room             = gsmtty_write_room,
2723         .chars_in_buffer        = gsmtty_chars_in_buffer,
2724         .flush_buffer           = gsmtty_flush_buffer,
2725         .ioctl                  = gsmtty_ioctl,
2726         .throttle               = gsmtty_throttle,
2727         .unthrottle             = gsmtty_unthrottle,
2728         .set_termios            = gsmtty_set_termios,
2729         .hangup                 = gsmtty_hangup,
2730         .wait_until_sent        = gsmtty_wait_until_sent,
2731         .tiocmget               = gsmtty_tiocmget,
2732         .tiocmset               = gsmtty_tiocmset,
2733         .break_ctl              = gsmtty_break_ctl,
2734 };
2735
2736
2737
2738 static int __init gsm_init(void)
2739 {
2740         /* Fill in our line protocol discipline, and register it */
2741         int status = tty_register_ldisc(N_GSM0710, &tty_ldisc_packet);
2742         if (status != 0) {
2743                 pr_err("n_gsm: can't register line discipline (err = %d)\n",
2744                                                                 status);
2745                 return status;
2746         }
2747
2748         gsm_tty_driver = alloc_tty_driver(256);
2749         if (!gsm_tty_driver) {
2750                 tty_unregister_ldisc(N_GSM0710);
2751                 pr_err("gsm_init: tty allocation failed.\n");
2752                 return -EINVAL;
2753         }
2754         gsm_tty_driver->owner   = THIS_MODULE;
2755         gsm_tty_driver->driver_name     = "gsmtty";
2756         gsm_tty_driver->name            = "gsmtty";
2757         gsm_tty_driver->major           = 0;    /* Dynamic */
2758         gsm_tty_driver->minor_start     = 0;
2759         gsm_tty_driver->type            = TTY_DRIVER_TYPE_SERIAL;
2760         gsm_tty_driver->subtype = SERIAL_TYPE_NORMAL;
2761         gsm_tty_driver->flags   = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV
2762                                                 | TTY_DRIVER_HARDWARE_BREAK;
2763         gsm_tty_driver->init_termios    = tty_std_termios;
2764         /* Fixme */
2765         gsm_tty_driver->init_termios.c_lflag &= ~ECHO;
2766         tty_set_operations(gsm_tty_driver, &gsmtty_ops);
2767
2768         spin_lock_init(&gsm_mux_lock);
2769
2770         if (tty_register_driver(gsm_tty_driver)) {
2771                 put_tty_driver(gsm_tty_driver);
2772                 tty_unregister_ldisc(N_GSM0710);
2773                 pr_err("gsm_init: tty registration failed.\n");
2774                 return -EBUSY;
2775         }
2776         pr_debug("gsm_init: loaded as %d,%d.\n",
2777                         gsm_tty_driver->major, gsm_tty_driver->minor_start);
2778         return 0;
2779 }
2780
2781 static void __exit gsm_exit(void)
2782 {
2783         int status = tty_unregister_ldisc(N_GSM0710);
2784         if (status != 0)
2785                 pr_err("n_gsm: can't unregister line discipline (err = %d)\n",
2786                                                                 status);
2787         tty_unregister_driver(gsm_tty_driver);
2788         put_tty_driver(gsm_tty_driver);
2789 }
2790
2791 module_init(gsm_init);
2792 module_exit(gsm_exit);
2793
2794
2795 MODULE_LICENSE("GPL");
2796 MODULE_ALIAS_LDISC(N_GSM0710);