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