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