tty.c revision ecaa3bda65cefebfce11cc7be4b8d9203f5ce12c 
1/*
2 * IPWireless 3G PCMCIA Network Driver
3 *
4 * Original code
5 *   by Stephen Blackheath <stephen@blacksapphire.com>,
6 *      Ben Martel <benm@symmetric.co.nz>
7 *
8 * Copyrighted as follows:
9 *   Copyright (C) 2004 by Symmetric Systems Ltd (NZ)
10 *
11 * Various driver changes and rewrites, port to new kernels
12 *   Copyright (C) 2006-2007 Jiri Kosina
13 *
14 * Misc code cleanups and updates
15 *   Copyright (C) 2007 David Sterba
16 */
17
18#include <linux/init.h>
19#include <linux/kernel.h>
20#include <linux/module.h>
21#include <linux/mutex.h>
22#include <linux/ppp_defs.h>
23#include <linux/if.h>
24#include <linux/if_ppp.h>
25#include <linux/sched.h>
26#include <linux/serial.h>
27#include <linux/slab.h>
28#include <linux/tty.h>
29#include <linux/tty_driver.h>
30#include <linux/tty_flip.h>
31#include <linux/uaccess.h>
32
33#include "tty.h"
34#include "network.h"
35#include "hardware.h"
36#include "main.h"
37
38#define IPWIRELESS_PCMCIA_START 	(0)
39#define IPWIRELESS_PCMCIA_MINORS	(24)
40#define IPWIRELESS_PCMCIA_MINOR_RANGE	(8)
41
42#define TTYTYPE_MODEM    (0)
43#define TTYTYPE_MONITOR  (1)
44#define TTYTYPE_RAS_RAW  (2)
45
46struct ipw_tty {
47	int index;
48	struct ipw_hardware *hardware;
49	unsigned int channel_idx;
50	unsigned int secondary_channel_idx;
51	int tty_type;
52	struct ipw_network *network;
53	struct tty_struct *linux_tty;
54	int open_count;
55	unsigned int control_lines;
56	struct mutex ipw_tty_mutex;
57	int tx_bytes_queued;
58	int closing;
59};
60
61static struct ipw_tty *ttys[IPWIRELESS_PCMCIA_MINORS];
62
63static struct tty_driver *ipw_tty_driver;
64
65static char *tty_type_name(int tty_type)
66{
67	static char *channel_names[] = {
68		"modem",
69		"monitor",
70		"RAS-raw"
71	};
72
73	return channel_names[tty_type];
74}
75
76static void report_registering(struct ipw_tty *tty)
77{
78	char *iftype = tty_type_name(tty->tty_type);
79
80	printk(KERN_INFO IPWIRELESS_PCCARD_NAME
81	       ": registering %s device ttyIPWp%d\n", iftype, tty->index);
82}
83
84static void report_deregistering(struct ipw_tty *tty)
85{
86	char *iftype = tty_type_name(tty->tty_type);
87
88	printk(KERN_INFO IPWIRELESS_PCCARD_NAME
89	       ": deregistering %s device ttyIPWp%d\n", iftype,
90	       tty->index);
91}
92
93static struct ipw_tty *get_tty(int index)
94{
95	/*
96	 * The 'ras_raw' channel is only available when 'loopback' mode
97	 * is enabled.
98	 * Number of minor starts with 16 (_RANGE * _RAS_RAW).
99	 */
100	if (!ipwireless_loopback && index >=
101			 IPWIRELESS_PCMCIA_MINOR_RANGE * TTYTYPE_RAS_RAW)
102		return NULL;
103
104	return ttys[index];
105}
106
107static int ipw_open(struct tty_struct *linux_tty, struct file *filp)
108{
109	struct ipw_tty *tty = get_tty(linux_tty->index);
110
111	if (!tty)
112		return -ENODEV;
113
114	mutex_lock(&tty->ipw_tty_mutex);
115
116	if (tty->closing) {
117		mutex_unlock(&tty->ipw_tty_mutex);
118		return -ENODEV;
119	}
120	if (tty->open_count == 0)
121		tty->tx_bytes_queued = 0;
122
123	tty->open_count++;
124
125	tty->linux_tty = linux_tty;
126	linux_tty->driver_data = tty;
127	linux_tty->low_latency = 1;
128
129	if (tty->tty_type == TTYTYPE_MODEM)
130		ipwireless_ppp_open(tty->network);
131
132	mutex_unlock(&tty->ipw_tty_mutex);
133
134	return 0;
135}
136
137static void do_ipw_close(struct ipw_tty *tty)
138{
139	tty->open_count--;
140
141	if (tty->open_count == 0) {
142		struct tty_struct *linux_tty = tty->linux_tty;
143
144		if (linux_tty != NULL) {
145			tty->linux_tty = NULL;
146			linux_tty->driver_data = NULL;
147
148			if (tty->tty_type == TTYTYPE_MODEM)
149				ipwireless_ppp_close(tty->network);
150		}
151	}
152}
153
154static void ipw_hangup(struct tty_struct *linux_tty)
155{
156	struct ipw_tty *tty = linux_tty->driver_data;
157
158	if (!tty)
159		return;
160
161	mutex_lock(&tty->ipw_tty_mutex);
162	if (tty->open_count == 0) {
163		mutex_unlock(&tty->ipw_tty_mutex);
164		return;
165	}
166
167	do_ipw_close(tty);
168
169	mutex_unlock(&tty->ipw_tty_mutex);
170}
171
172static void ipw_close(struct tty_struct *linux_tty, struct file *filp)
173{
174	ipw_hangup(linux_tty);
175}
176
177/* Take data received from hardware, and send it out the tty */
178void ipwireless_tty_received(struct ipw_tty *tty, unsigned char *data,
179			unsigned int length)
180{
181	struct tty_struct *linux_tty;
182	int work = 0;
183
184	mutex_lock(&tty->ipw_tty_mutex);
185	linux_tty = tty->linux_tty;
186	if (linux_tty == NULL) {
187		mutex_unlock(&tty->ipw_tty_mutex);
188		return;
189	}
190
191	if (!tty->open_count) {
192		mutex_unlock(&tty->ipw_tty_mutex);
193		return;
194	}
195	mutex_unlock(&tty->ipw_tty_mutex);
196
197	work = tty_insert_flip_string(linux_tty, data, length);
198
199	if (work != length)
200		printk(KERN_DEBUG IPWIRELESS_PCCARD_NAME
201				": %d chars not inserted to flip buffer!\n",
202				length - work);
203
204	/*
205	 * This may sleep if ->low_latency is set
206	 */
207	if (work)
208		tty_flip_buffer_push(linux_tty);
209}
210
211static void ipw_write_packet_sent_callback(void *callback_data,
212					   unsigned int packet_length)
213{
214	struct ipw_tty *tty = callback_data;
215
216	/*
217	 * Packet has been sent, so we subtract the number of bytes from our
218	 * tally of outstanding TX bytes.
219	 */
220	tty->tx_bytes_queued -= packet_length;
221}
222
223static int ipw_write(struct tty_struct *linux_tty,
224		     const unsigned char *buf, int count)
225{
226	struct ipw_tty *tty = linux_tty->driver_data;
227	int room, ret;
228
229	if (!tty)
230		return -ENODEV;
231
232	mutex_lock(&tty->ipw_tty_mutex);
233	if (!tty->open_count) {
234		mutex_unlock(&tty->ipw_tty_mutex);
235		return -EINVAL;
236	}
237
238	room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
239	if (room < 0)
240		room = 0;
241	/* Don't allow caller to write any more than we have room for */
242	if (count > room)
243		count = room;
244
245	if (count == 0) {
246		mutex_unlock(&tty->ipw_tty_mutex);
247		return 0;
248	}
249
250	ret = ipwireless_send_packet(tty->hardware, IPW_CHANNEL_RAS,
251			       buf, count,
252			       ipw_write_packet_sent_callback, tty);
253	if (ret == -1) {
254		mutex_unlock(&tty->ipw_tty_mutex);
255		return 0;
256	}
257
258	tty->tx_bytes_queued += count;
259	mutex_unlock(&tty->ipw_tty_mutex);
260
261	return count;
262}
263
264static int ipw_write_room(struct tty_struct *linux_tty)
265{
266	struct ipw_tty *tty = linux_tty->driver_data;
267	int room;
268
269	/* FIXME: Exactly how is the tty object locked here .. */
270	if (!tty)
271		return -ENODEV;
272
273	if (!tty->open_count)
274		return -EINVAL;
275
276	room = IPWIRELESS_TX_QUEUE_SIZE - tty->tx_bytes_queued;
277	if (room < 0)
278		room = 0;
279
280	return room;
281}
282
283static int ipwireless_get_serial_info(struct ipw_tty *tty,
284				      struct serial_struct __user *retinfo)
285{
286	struct serial_struct tmp;
287
288	if (!retinfo)
289		return (-EFAULT);
290
291	memset(&tmp, 0, sizeof(tmp));
292	tmp.type = PORT_UNKNOWN;
293	tmp.line = tty->index;
294	tmp.port = 0;
295	tmp.irq = 0;
296	tmp.flags = 0;
297	tmp.baud_base = 115200;
298	tmp.close_delay = 0;
299	tmp.closing_wait = 0;
300	tmp.custom_divisor = 0;
301	tmp.hub6 = 0;
302	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
303		return -EFAULT;
304
305	return 0;
306}
307
308static int ipw_chars_in_buffer(struct tty_struct *linux_tty)
309{
310	struct ipw_tty *tty = linux_tty->driver_data;
311
312	if (!tty)
313		return 0;
314
315	if (!tty->open_count)
316		return 0;
317
318	return tty->tx_bytes_queued;
319}
320
321static int get_control_lines(struct ipw_tty *tty)
322{
323	unsigned int my = tty->control_lines;
324	unsigned int out = 0;
325
326	if (my & IPW_CONTROL_LINE_RTS)
327		out |= TIOCM_RTS;
328	if (my & IPW_CONTROL_LINE_DTR)
329		out |= TIOCM_DTR;
330	if (my & IPW_CONTROL_LINE_CTS)
331		out |= TIOCM_CTS;
332	if (my & IPW_CONTROL_LINE_DSR)
333		out |= TIOCM_DSR;
334	if (my & IPW_CONTROL_LINE_DCD)
335		out |= TIOCM_CD;
336
337	return out;
338}
339
340static int set_control_lines(struct ipw_tty *tty, unsigned int set,
341			     unsigned int clear)
342{
343	int ret;
344
345	if (set & TIOCM_RTS) {
346		ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 1);
347		if (ret)
348			return ret;
349		if (tty->secondary_channel_idx != -1) {
350			ret = ipwireless_set_RTS(tty->hardware,
351					  tty->secondary_channel_idx, 1);
352			if (ret)
353				return ret;
354		}
355	}
356	if (set & TIOCM_DTR) {
357		ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 1);
358		if (ret)
359			return ret;
360		if (tty->secondary_channel_idx != -1) {
361			ret = ipwireless_set_DTR(tty->hardware,
362					  tty->secondary_channel_idx, 1);
363			if (ret)
364				return ret;
365		}
366	}
367	if (clear & TIOCM_RTS) {
368		ret = ipwireless_set_RTS(tty->hardware, tty->channel_idx, 0);
369		if (tty->secondary_channel_idx != -1) {
370			ret = ipwireless_set_RTS(tty->hardware,
371					  tty->secondary_channel_idx, 0);
372			if (ret)
373				return ret;
374		}
375	}
376	if (clear & TIOCM_DTR) {
377		ret = ipwireless_set_DTR(tty->hardware, tty->channel_idx, 0);
378		if (tty->secondary_channel_idx != -1) {
379			ret = ipwireless_set_DTR(tty->hardware,
380					  tty->secondary_channel_idx, 0);
381			if (ret)
382				return ret;
383		}
384	}
385	return 0;
386}
387
388static int ipw_tiocmget(struct tty_struct *linux_tty)
389{
390	struct ipw_tty *tty = linux_tty->driver_data;
391	/* FIXME: Exactly how is the tty object locked here .. */
392
393	if (!tty)
394		return -ENODEV;
395
396	if (!tty->open_count)
397		return -EINVAL;
398
399	return get_control_lines(tty);
400}
401
402static int
403ipw_tiocmset(struct tty_struct *linux_tty,
404	     unsigned int set, unsigned int clear)
405{
406	struct ipw_tty *tty = linux_tty->driver_data;
407	/* FIXME: Exactly how is the tty object locked here .. */
408
409	if (!tty)
410		return -ENODEV;
411
412	if (!tty->open_count)
413		return -EINVAL;
414
415	return set_control_lines(tty, set, clear);
416}
417
418static int ipw_ioctl(struct tty_struct *linux_tty,
419		     unsigned int cmd, unsigned long arg)
420{
421	struct ipw_tty *tty = linux_tty->driver_data;
422
423	if (!tty)
424		return -ENODEV;
425
426	if (!tty->open_count)
427		return -EINVAL;
428
429	/* FIXME: Exactly how is the tty object locked here .. */
430
431	switch (cmd) {
432	case TIOCGSERIAL:
433		return ipwireless_get_serial_info(tty, (void __user *) arg);
434
435	case TIOCSSERIAL:
436		return 0;	/* Keeps the PCMCIA scripts happy. */
437	}
438
439	if (tty->tty_type == TTYTYPE_MODEM) {
440		switch (cmd) {
441		case PPPIOCGCHAN:
442			{
443				int chan = ipwireless_ppp_channel_index(
444							tty->network);
445
446				if (chan < 0)
447					return -ENODEV;
448				if (put_user(chan, (int __user *) arg))
449					return -EFAULT;
450			}
451			return 0;
452
453		case PPPIOCGUNIT:
454			{
455				int unit = ipwireless_ppp_unit_number(
456						tty->network);
457
458				if (unit < 0)
459					return -ENODEV;
460				if (put_user(unit, (int __user *) arg))
461					return -EFAULT;
462			}
463			return 0;
464
465		case FIONREAD:
466			{
467				int val = 0;
468
469				if (put_user(val, (int __user *) arg))
470					return -EFAULT;
471			}
472			return 0;
473		case TCFLSH:
474			return tty_perform_flush(linux_tty, arg);
475		}
476	}
477	return -ENOIOCTLCMD;
478}
479
480static int add_tty(int j,
481		    struct ipw_hardware *hardware,
482		    struct ipw_network *network, int channel_idx,
483		    int secondary_channel_idx, int tty_type)
484{
485	ttys[j] = kzalloc(sizeof(struct ipw_tty), GFP_KERNEL);
486	if (!ttys[j])
487		return -ENOMEM;
488	ttys[j]->index = j;
489	ttys[j]->hardware = hardware;
490	ttys[j]->channel_idx = channel_idx;
491	ttys[j]->secondary_channel_idx = secondary_channel_idx;
492	ttys[j]->network = network;
493	ttys[j]->tty_type = tty_type;
494	mutex_init(&ttys[j]->ipw_tty_mutex);
495
496	tty_register_device(ipw_tty_driver, j, NULL);
497	ipwireless_associate_network_tty(network, channel_idx, ttys[j]);
498
499	if (secondary_channel_idx != -1)
500		ipwireless_associate_network_tty(network,
501						 secondary_channel_idx,
502						 ttys[j]);
503	if (get_tty(j) == ttys[j])
504		report_registering(ttys[j]);
505	return 0;
506}
507
508struct ipw_tty *ipwireless_tty_create(struct ipw_hardware *hardware,
509				      struct ipw_network *network)
510{
511	int i, j;
512
513	for (i = 0; i < IPWIRELESS_PCMCIA_MINOR_RANGE; i++) {
514		int allfree = 1;
515
516		for (j = i; j < IPWIRELESS_PCMCIA_MINORS;
517				j += IPWIRELESS_PCMCIA_MINOR_RANGE)
518			if (ttys[j] != NULL) {
519				allfree = 0;
520				break;
521			}
522
523		if (allfree) {
524			j = i;
525
526			if (add_tty(j, hardware, network,
527					IPW_CHANNEL_DIALLER, IPW_CHANNEL_RAS,
528					TTYTYPE_MODEM))
529				return NULL;
530
531			j += IPWIRELESS_PCMCIA_MINOR_RANGE;
532			if (add_tty(j, hardware, network,
533					IPW_CHANNEL_DIALLER, -1,
534					TTYTYPE_MONITOR))
535				return NULL;
536
537			j += IPWIRELESS_PCMCIA_MINOR_RANGE;
538			if (add_tty(j, hardware, network,
539					IPW_CHANNEL_RAS, -1,
540					TTYTYPE_RAS_RAW))
541				return NULL;
542
543			return ttys[i];
544		}
545	}
546	return NULL;
547}
548
549/*
550 * Must be called before ipwireless_network_free().
551 */
552void ipwireless_tty_free(struct ipw_tty *tty)
553{
554	int j;
555	struct ipw_network *network = ttys[tty->index]->network;
556
557	for (j = tty->index; j < IPWIRELESS_PCMCIA_MINORS;
558			j += IPWIRELESS_PCMCIA_MINOR_RANGE) {
559		struct ipw_tty *ttyj = ttys[j];
560
561		if (ttyj) {
562			mutex_lock(&ttyj->ipw_tty_mutex);
563			if (get_tty(j) == ttyj)
564				report_deregistering(ttyj);
565			ttyj->closing = 1;
566			if (ttyj->linux_tty != NULL) {
567				mutex_unlock(&ttyj->ipw_tty_mutex);
568				tty_hangup(ttyj->linux_tty);
569				/* Wait till the tty_hangup has completed */
570				flush_work_sync(&ttyj->linux_tty->hangup_work);
571				/* FIXME: Exactly how is the tty object locked here
572				   against a parallel ioctl etc */
573				mutex_lock(&ttyj->ipw_tty_mutex);
574			}
575			while (ttyj->open_count)
576				do_ipw_close(ttyj);
577			ipwireless_disassociate_network_ttys(network,
578							     ttyj->channel_idx);
579			tty_unregister_device(ipw_tty_driver, j);
580			ttys[j] = NULL;
581			mutex_unlock(&ttyj->ipw_tty_mutex);
582			kfree(ttyj);
583		}
584	}
585}
586
587static const struct tty_operations tty_ops = {
588	.open = ipw_open,
589	.close = ipw_close,
590	.hangup = ipw_hangup,
591	.write = ipw_write,
592	.write_room = ipw_write_room,
593	.ioctl = ipw_ioctl,
594	.chars_in_buffer = ipw_chars_in_buffer,
595	.tiocmget = ipw_tiocmget,
596	.tiocmset = ipw_tiocmset,
597};
598
599int ipwireless_tty_init(void)
600{
601	int result;
602
603	ipw_tty_driver = alloc_tty_driver(IPWIRELESS_PCMCIA_MINORS);
604	if (!ipw_tty_driver)
605		return -ENOMEM;
606
607	ipw_tty_driver->driver_name = IPWIRELESS_PCCARD_NAME;
608	ipw_tty_driver->name = "ttyIPWp";
609	ipw_tty_driver->major = 0;
610	ipw_tty_driver->minor_start = IPWIRELESS_PCMCIA_START;
611	ipw_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
612	ipw_tty_driver->subtype = SERIAL_TYPE_NORMAL;
613	ipw_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
614	ipw_tty_driver->init_termios = tty_std_termios;
615	ipw_tty_driver->init_termios.c_cflag =
616	    B9600 | CS8 | CREAD | HUPCL | CLOCAL;
617	ipw_tty_driver->init_termios.c_ispeed = 9600;
618	ipw_tty_driver->init_termios.c_ospeed = 9600;
619	tty_set_operations(ipw_tty_driver, &tty_ops);
620	result = tty_register_driver(ipw_tty_driver);
621	if (result) {
622		printk(KERN_ERR IPWIRELESS_PCCARD_NAME
623		       ": failed to register tty driver\n");
624		put_tty_driver(ipw_tty_driver);
625		return result;
626	}
627
628	return 0;
629}
630
631void ipwireless_tty_release(void)
632{
633	int ret;
634
635	ret = tty_unregister_driver(ipw_tty_driver);
636	put_tty_driver(ipw_tty_driver);
637	if (ret != 0)
638		printk(KERN_ERR IPWIRELESS_PCCARD_NAME
639			": tty_unregister_driver failed with code %d\n", ret);
640}
641
642int ipwireless_tty_is_modem(struct ipw_tty *tty)
643{
644	return tty->tty_type == TTYTYPE_MODEM;
645}
646
647void
648ipwireless_tty_notify_control_line_change(struct ipw_tty *tty,
649					  unsigned int channel_idx,
650					  unsigned int control_lines,
651					  unsigned int changed_mask)
652{
653	unsigned int old_control_lines = tty->control_lines;
654
655	tty->control_lines = (tty->control_lines & ~changed_mask)
656		| (control_lines & changed_mask);
657
658	/*
659	 * If DCD is de-asserted, we close the tty so pppd can tell that we
660	 * have gone offline.
661	 */
662	if ((old_control_lines & IPW_CONTROL_LINE_DCD)
663			&& !(tty->control_lines & IPW_CONTROL_LINE_DCD)
664			&& tty->linux_tty) {
665		tty_hangup(tty->linux_tty);
666	}
667}
668
669