Kernel

Kernel Git Source Tree

Root/drivers/tty/n_gsm.c

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

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/tty/n_gsm.c

interactive