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