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