PageRenderTime 48ms CodeModel.GetById 21ms app.highlight 22ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/net/irda/irtty-sir.c

http://github.com/mirrors/linux
C | 570 lines | 298 code | 112 blank | 160 comment | 51 complexity | 7c8823d1a661b67424429ee1c390d16a MD5 | raw file
  1/*********************************************************************
  2 *                
  3 * Filename:      irtty-sir.c
  4 * Version:       2.0
  5 * Description:   IrDA line discipline implementation
  6 * Status:        Experimental.
  7 * Author:        Dag Brattli <dagb@cs.uit.no>
  8 * Created at:    Tue Dec  9 21:18:38 1997
  9 * Modified at:   Sun Oct 27 22:13:30 2002
 10 * Modified by:   Martin Diehl <mad@mdiehl.de>
 11 * Sources:       slip.c by Laurence Culhane,   <loz@holmes.demon.co.uk>
 12 *                          Fred N. van Kempen, <waltje@uwalt.nl.mugnet.org>
 13 * 
 14 *     Copyright (c) 1998-2000 Dag Brattli,
 15 *     Copyright (c) 2002 Martin Diehl,
 16 *     All Rights Reserved.
 17 *      
 18 *     This program is free software; you can redistribute it and/or 
 19 *     modify it under the terms of the GNU General Public License as 
 20 *     published by the Free Software Foundation; either version 2 of 
 21 *     the License, or (at your option) any later version.
 22 *  
 23 *     Neither Dag Brattli nor University of Tromsø admit liability nor
 24 *     provide warranty for any of this software. This material is 
 25 *     provided "AS-IS" and at no charge.
 26 *     
 27 ********************************************************************/    
 28
 29#include <linux/module.h>
 30#include <linux/kernel.h>
 31#include <linux/slab.h>
 32#include <linux/tty.h>
 33#include <linux/init.h>
 34#include <asm/uaccess.h>
 35#include <linux/delay.h>
 36#include <linux/mutex.h>
 37
 38#include <net/irda/irda.h>
 39#include <net/irda/irda_device.h>
 40
 41#include "sir-dev.h"
 42#include "irtty-sir.h"
 43
 44static int qos_mtt_bits = 0x03;      /* 5 ms or more */
 45
 46module_param(qos_mtt_bits, int, 0);
 47MODULE_PARM_DESC(qos_mtt_bits, "Minimum Turn Time");
 48
 49/* ------------------------------------------------------- */
 50
 51/* device configuration callbacks always invoked with irda-thread context */
 52
 53/* find out, how many chars we have in buffers below us
 54 * this is allowed to lie, i.e. return less chars than we
 55 * actually have. The returned value is used to determine
 56 * how long the irdathread should wait before doing the
 57 * real blocking wait_until_sent()
 58 */
 59
 60static int irtty_chars_in_buffer(struct sir_dev *dev)
 61{
 62	struct sirtty_cb *priv = dev->priv;
 63
 64	IRDA_ASSERT(priv != NULL, return -1;);
 65	IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
 66
 67	return tty_chars_in_buffer(priv->tty);
 68}
 69
 70/* Wait (sleep) until underlaying hardware finished transmission
 71 * i.e. hardware buffers are drained
 72 * this must block and not return before all characters are really sent
 73 *
 74 * If the tty sits on top of a 16550A-like uart, there are typically
 75 * up to 16 bytes in the fifo - f.e. 9600 bps 8N1 needs 16.7 msec
 76 *
 77 * With usbserial the uart-fifo is basically replaced by the converter's
 78 * outgoing endpoint buffer, which can usually hold 64 bytes (at least).
 79 * With pl2303 it appears we are safe with 60msec here.
 80 *
 81 * I really wish all serial drivers would provide
 82 * correct implementation of wait_until_sent()
 83 */
 84
 85#define USBSERIAL_TX_DONE_DELAY	60
 86
 87static void irtty_wait_until_sent(struct sir_dev *dev)
 88{
 89	struct sirtty_cb *priv = dev->priv;
 90	struct tty_struct *tty;
 91
 92	IRDA_ASSERT(priv != NULL, return;);
 93	IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
 94
 95	tty = priv->tty;
 96	if (tty->ops->wait_until_sent) {
 97		tty->ops->wait_until_sent(tty, msecs_to_jiffies(100));
 98	}
 99	else {
100		msleep(USBSERIAL_TX_DONE_DELAY);
101	}
102}
103
104/* 
105 *  Function irtty_change_speed (dev, speed)
106 *
107 *    Change the speed of the serial port.
108 *
109 * This may sleep in set_termios (usbserial driver f.e.) and must
110 * not be called from interrupt/timer/tasklet therefore.
111 * All such invocations are deferred to kIrDAd now so we can sleep there.
112 */
113
114static int irtty_change_speed(struct sir_dev *dev, unsigned speed)
115{
116	struct sirtty_cb *priv = dev->priv;
117	struct tty_struct *tty;
118        struct ktermios old_termios;
119	int cflag;
120
121	IRDA_ASSERT(priv != NULL, return -1;);
122	IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
123
124	tty = priv->tty;
125
126	down_write(&tty->termios_rwsem);
127	old_termios = tty->termios;
128	cflag = tty->termios.c_cflag;
129	tty_encode_baud_rate(tty, speed, speed);
130	if (tty->ops->set_termios)
131		tty->ops->set_termios(tty, &old_termios);
132	priv->io.speed = speed;
133	up_write(&tty->termios_rwsem);
134
135	return 0;
136}
137
138/*
139 * Function irtty_set_dtr_rts (dev, dtr, rts)
140 *
141 *    This function can be used by dongles etc. to set or reset the status
142 *    of the dtr and rts lines
143 */
144
145static int irtty_set_dtr_rts(struct sir_dev *dev, int dtr, int rts)
146{
147	struct sirtty_cb *priv = dev->priv;
148	int set = 0;
149	int clear = 0;
150
151	IRDA_ASSERT(priv != NULL, return -1;);
152	IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
153
154	if (rts)
155		set |= TIOCM_RTS;
156	else
157		clear |= TIOCM_RTS;
158	if (dtr)
159		set |= TIOCM_DTR;
160	else
161		clear |= TIOCM_DTR;
162
163	/*
164	 * We can't use ioctl() because it expects a non-null file structure,
165	 * and we don't have that here.
166	 * This function is not yet defined for all tty driver, so
167	 * let's be careful... Jean II
168	 */
169	IRDA_ASSERT(priv->tty->ops->tiocmset != NULL, return -1;);
170	priv->tty->ops->tiocmset(priv->tty, set, clear);
171
172	return 0;
173}
174
175/* ------------------------------------------------------- */
176
177/* called from sir_dev when there is more data to send
178 * context is either netdev->hard_xmit or some transmit-completion bh
179 * i.e. we are under spinlock here and must not sleep.
180 */
181
182static int irtty_do_write(struct sir_dev *dev, const unsigned char *ptr, size_t len)
183{
184	struct sirtty_cb *priv = dev->priv;
185	struct tty_struct *tty;
186	int writelen;
187
188	IRDA_ASSERT(priv != NULL, return -1;);
189	IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -1;);
190
191	tty = priv->tty;
192	if (!tty->ops->write)
193		return 0;
194	set_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
195	writelen = tty_write_room(tty);
196	if (writelen > len)
197		writelen = len;
198	return tty->ops->write(tty, ptr, writelen);
199}
200
201/* ------------------------------------------------------- */
202
203/* irda line discipline callbacks */
204
205/* 
206 *  Function irtty_receive_buf( tty, cp, count)
207 *
208 *    Handle the 'receiver data ready' interrupt.  This function is called
209 *    by the 'tty_io' module in the kernel when a block of IrDA data has
210 *    been received, which can now be decapsulated and delivered for
211 *    further processing 
212 *
213 * calling context depends on underlying driver and tty->port->low_latency!
214 * for example (low_latency: 1 / 0):
215 * serial.c:	uart-interrupt / softint
216 * usbserial:	urb-complete-interrupt / softint
217 */
218
219static void irtty_receive_buf(struct tty_struct *tty, const unsigned char *cp,
220			      char *fp, int count) 
221{
222	struct sir_dev *dev;
223	struct sirtty_cb *priv = tty->disc_data;
224	int	i;
225
226	IRDA_ASSERT(priv != NULL, return;);
227	IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
228
229	if (unlikely(count==0))		/* yes, this happens */
230		return;
231
232	dev = priv->dev;
233	if (!dev) {
234		net_warn_ratelimited("%s(), not ready yet!\n", __func__);
235		return;
236	}
237
238	for (i = 0; i < count; i++) {
239		/* 
240		 *  Characters received with a parity error, etc?
241		 */
242 		if (fp && *fp++) { 
243			pr_debug("Framing or parity error!\n");
244			sirdev_receive(dev, NULL, 0);	/* notify sir_dev (updating stats) */
245			return;
246 		}
247	}
248
249	sirdev_receive(dev, cp, count);
250}
251
252/*
253 * Function irtty_write_wakeup (tty)
254 *
255 *    Called by the driver when there's room for more data.  If we have
256 *    more packets to send, we send them here.
257 *
258 */
259static void irtty_write_wakeup(struct tty_struct *tty) 
260{
261	struct sirtty_cb *priv = tty->disc_data;
262
263	IRDA_ASSERT(priv != NULL, return;);
264	IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
265
266	clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
267	if (priv->dev)
268		sirdev_write_complete(priv->dev);
269}
270
271/* ------------------------------------------------------- */
272
273/*
274 * Function irtty_stop_receiver (tty, stop)
275 *
276 */
277
278static inline void irtty_stop_receiver(struct tty_struct *tty, int stop)
279{
280	struct ktermios old_termios;
281	int cflag;
282
283	down_write(&tty->termios_rwsem);
284	old_termios = tty->termios;
285	cflag = tty->termios.c_cflag;
286	
287	if (stop)
288		cflag &= ~CREAD;
289	else
290		cflag |= CREAD;
291
292	tty->termios.c_cflag = cflag;
293	if (tty->ops->set_termios)
294		tty->ops->set_termios(tty, &old_termios);
295	up_write(&tty->termios_rwsem);
296}
297
298/*****************************************************************/
299
300/* serialize ldisc open/close with sir_dev */
301static DEFINE_MUTEX(irtty_mutex);
302
303/* notifier from sir_dev when irda% device gets opened (ifup) */
304
305static int irtty_start_dev(struct sir_dev *dev)
306{
307	struct sirtty_cb *priv;
308	struct tty_struct *tty;
309
310	/* serialize with ldisc open/close */
311	mutex_lock(&irtty_mutex);
312
313	priv = dev->priv;
314	if (unlikely(!priv || priv->magic!=IRTTY_MAGIC)) {
315		mutex_unlock(&irtty_mutex);
316		return -ESTALE;
317	}
318
319	tty = priv->tty;
320
321	if (tty->ops->start)
322		tty->ops->start(tty);
323	/* Make sure we can receive more data */
324	irtty_stop_receiver(tty, FALSE);
325
326	mutex_unlock(&irtty_mutex);
327	return 0;
328}
329
330/* notifier from sir_dev when irda% device gets closed (ifdown) */
331
332static int irtty_stop_dev(struct sir_dev *dev)
333{
334	struct sirtty_cb *priv;
335	struct tty_struct *tty;
336
337	/* serialize with ldisc open/close */
338	mutex_lock(&irtty_mutex);
339
340	priv = dev->priv;
341	if (unlikely(!priv || priv->magic!=IRTTY_MAGIC)) {
342		mutex_unlock(&irtty_mutex);
343		return -ESTALE;
344	}
345
346	tty = priv->tty;
347
348	/* Make sure we don't receive more data */
349	irtty_stop_receiver(tty, TRUE);
350	if (tty->ops->stop)
351		tty->ops->stop(tty);
352
353	mutex_unlock(&irtty_mutex);
354
355	return 0;
356}
357
358/* ------------------------------------------------------- */
359
360static struct sir_driver sir_tty_drv = {
361	.owner			= THIS_MODULE,
362	.driver_name		= "sir_tty",
363	.start_dev		= irtty_start_dev,
364	.stop_dev		= irtty_stop_dev,
365	.do_write		= irtty_do_write,
366	.chars_in_buffer	= irtty_chars_in_buffer,
367	.wait_until_sent	= irtty_wait_until_sent,
368	.set_speed		= irtty_change_speed,
369	.set_dtr_rts		= irtty_set_dtr_rts,
370};
371
372/* ------------------------------------------------------- */
373
374/*
375 * Function irtty_ioctl (tty, file, cmd, arg)
376 *
377 *     The Swiss army knife of system calls :-)
378 *
379 */
380static int irtty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
381{
382	struct irtty_info { char name[6]; } info;
383	struct sir_dev *dev;
384	struct sirtty_cb *priv = tty->disc_data;
385	int err = 0;
386
387	IRDA_ASSERT(priv != NULL, return -ENODEV;);
388	IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -EBADR;);
389
390	pr_debug("%s(cmd=0x%X)\n", __func__, cmd);
391
392	dev = priv->dev;
393	IRDA_ASSERT(dev != NULL, return -1;);
394
395	switch (cmd) {
396	case IRTTY_IOCTDONGLE:
397		/* this call blocks for completion */
398		err = sirdev_set_dongle(dev, (IRDA_DONGLE) arg);
399		break;
400
401	case IRTTY_IOCGET:
402		IRDA_ASSERT(dev->netdev != NULL, return -1;);
403
404		memset(&info, 0, sizeof(info)); 
405		strncpy(info.name, dev->netdev->name, sizeof(info.name)-1);
406
407		if (copy_to_user((void __user *)arg, &info, sizeof(info)))
408			err = -EFAULT;
409		break;
410	default:
411		err = tty_mode_ioctl(tty, file, cmd, arg);
412		break;
413	}
414	return err;
415}
416
417
418/* 
419 *  Function irtty_open(tty)
420 *
421 *    This function is called by the TTY module when the IrDA line
422 *    discipline is called for.  Because we are sure the tty line exists,
423 *    we only have to link it to a free IrDA channel.  
424 */
425static int irtty_open(struct tty_struct *tty) 
426{
427	struct sir_dev *dev;
428	struct sirtty_cb *priv;
429	int ret = 0;
430
431	/* Module stuff handled via irda_ldisc.owner - Jean II */
432
433	/* stop the underlying  driver */
434	irtty_stop_receiver(tty, TRUE);
435	if (tty->ops->stop)
436		tty->ops->stop(tty);
437
438	tty_driver_flush_buffer(tty);
439	
440	/* apply mtt override */
441	sir_tty_drv.qos_mtt_bits = qos_mtt_bits;
442
443	/* get a sir device instance for this driver */
444	dev = sirdev_get_instance(&sir_tty_drv, tty->name);
445	if (!dev) {
446		ret = -ENODEV;
447		goto out;
448	}
449
450	/* allocate private device info block */
451	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
452	if (!priv) {
453		ret = -ENOMEM;
454		goto out_put;
455	}
456
457	priv->magic = IRTTY_MAGIC;
458	priv->tty = tty;
459	priv->dev = dev;
460
461	/* serialize with start_dev - in case we were racing with ifup */
462	mutex_lock(&irtty_mutex);
463
464	dev->priv = priv;
465	tty->disc_data = priv;
466	tty->receive_room = 65536;
467
468	mutex_unlock(&irtty_mutex);
469
470	pr_debug("%s - %s: irda line discipline opened\n", __func__, tty->name);
471
472	return 0;
473
474out_put:
475	sirdev_put_instance(dev);
476out:
477	return ret;
478}
479
480/* 
481 *  Function irtty_close (tty)
482 *
483 *    Close down a IrDA channel. This means flushing out any pending queues,
484 *    and then restoring the TTY line discipline to what it was before it got
485 *    hooked to IrDA (which usually is TTY again).  
486 */
487static void irtty_close(struct tty_struct *tty) 
488{
489	struct sirtty_cb *priv = tty->disc_data;
490
491	IRDA_ASSERT(priv != NULL, return;);
492	IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
493
494	/* Hm, with a dongle attached the dongle driver wants
495	 * to close the dongle - which requires the use of
496	 * some tty write and/or termios or ioctl operations.
497	 * Are we allowed to call those when already requested
498	 * to shutdown the ldisc?
499	 * If not, we should somehow mark the dev being staled.
500	 * Question remains, how to close the dongle in this case...
501	 * For now let's assume we are granted to issue tty driver calls
502	 * until we return here from the ldisc close. I'm just wondering
503	 * how this behaves with hotpluggable serial hardware like
504	 * rs232-pcmcia card or usb-serial...
505	 *
506	 * priv->tty = NULL?;
507	 */
508
509	/* we are dead now */
510	tty->disc_data = NULL;
511
512	sirdev_put_instance(priv->dev);
513
514	/* Stop tty */
515	clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
516	if (tty->ops->stop)
517		tty->ops->stop(tty);
518
519	kfree(priv);
520
521	pr_debug("%s - %s: irda line discipline closed\n", __func__, tty->name);
522}
523
524/* ------------------------------------------------------- */
525
526static struct tty_ldisc_ops irda_ldisc = {
527	.magic		= TTY_LDISC_MAGIC,
528 	.name		= "irda",
529	.flags		= 0,
530	.open		= irtty_open,
531	.close		= irtty_close,
532	.read		= NULL,
533	.write		= NULL,
534	.ioctl		= irtty_ioctl,
535 	.poll		= NULL,
536	.receive_buf	= irtty_receive_buf,
537	.write_wakeup	= irtty_write_wakeup,
538	.owner		= THIS_MODULE,
539};
540
541/* ------------------------------------------------------- */
542
543static int __init irtty_sir_init(void)
544{
545	int err;
546
547	if ((err = tty_register_ldisc(N_IRDA, &irda_ldisc)) != 0)
548		net_err_ratelimited("IrDA: can't register line discipline (err = %d)\n",
549				    err);
550	return err;
551}
552
553static void __exit irtty_sir_cleanup(void) 
554{
555	int err;
556
557	if ((err = tty_unregister_ldisc(N_IRDA))) {
558		net_err_ratelimited("%s(), can't unregister line discipline (err = %d)\n",
559				    __func__, err);
560	}
561}
562
563module_init(irtty_sir_init);
564module_exit(irtty_sir_cleanup);
565
566MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
567MODULE_DESCRIPTION("IrDA TTY device driver");
568MODULE_ALIAS_LDISC(N_IRDA);
569MODULE_LICENSE("GPL");
570