tty: make receive_buf() return the amout of bytes received
[linux-2.6.git] / 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/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
44 static int qos_mtt_bits = 0x03;      /* 5 ms or more */
45
46 module_param(qos_mtt_bits, int, 0);
47 MODULE_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
60 static 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
87 static 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
114 static 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         mutex_lock(&tty->termios_mutex);
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         mutex_unlock(&tty->termios_mutex);
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
145 static 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
182 static 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->low_latency!
214  * for example (low_latency: 1 / 0):
215  * serial.c:    uart-interrupt / softint
216  * usbserial:   urb-complete-interrupt / softint
217  */
218
219 static unsigned int irtty_receive_buf(struct tty_struct *tty,
220                 const unsigned char *cp, 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 -ENODEV;);
227         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -EINVAL;);
228
229         if (unlikely(count==0))         /* yes, this happens */
230                 return 0;
231
232         dev = priv->dev;
233         if (!dev) {
234                 IRDA_WARNING("%s(), not ready yet!\n", __func__);
235                 return -ENODEV;
236         }
237
238         for (i = 0; i < count; i++) {
239                 /* 
240                  *  Characters received with a parity error, etc?
241                  */
242                 if (fp && *fp++) { 
243                         IRDA_DEBUG(0, "Framing or parity error!\n");
244                         sirdev_receive(dev, NULL, 0);   /* notify sir_dev (updating stats) */
245                         return -EINVAL;
246                 }
247         }
248
249         sirdev_receive(dev, cp, count);
250
251         return count;
252 }
253
254 /*
255  * Function irtty_write_wakeup (tty)
256  *
257  *    Called by the driver when there's room for more data.  If we have
258  *    more packets to send, we send them here.
259  *
260  */
261 static void irtty_write_wakeup(struct tty_struct *tty) 
262 {
263         struct sirtty_cb *priv = tty->disc_data;
264
265         IRDA_ASSERT(priv != NULL, return;);
266         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
267
268         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
269         if (priv->dev)
270                 sirdev_write_complete(priv->dev);
271 }
272
273 /* ------------------------------------------------------- */
274
275 /*
276  * Function irtty_stop_receiver (tty, stop)
277  *
278  */
279
280 static inline void irtty_stop_receiver(struct tty_struct *tty, int stop)
281 {
282         struct ktermios old_termios;
283         int cflag;
284
285         mutex_lock(&tty->termios_mutex);
286         old_termios = *(tty->termios);
287         cflag = tty->termios->c_cflag;
288         
289         if (stop)
290                 cflag &= ~CREAD;
291         else
292                 cflag |= CREAD;
293
294         tty->termios->c_cflag = cflag;
295         if (tty->ops->set_termios)
296                 tty->ops->set_termios(tty, &old_termios);
297         mutex_unlock(&tty->termios_mutex);
298 }
299
300 /*****************************************************************/
301
302 /* serialize ldisc open/close with sir_dev */
303 static DEFINE_MUTEX(irtty_mutex);
304
305 /* notifier from sir_dev when irda% device gets opened (ifup) */
306
307 static int irtty_start_dev(struct sir_dev *dev)
308 {
309         struct sirtty_cb *priv;
310         struct tty_struct *tty;
311
312         /* serialize with ldisc open/close */
313         mutex_lock(&irtty_mutex);
314
315         priv = dev->priv;
316         if (unlikely(!priv || priv->magic!=IRTTY_MAGIC)) {
317                 mutex_unlock(&irtty_mutex);
318                 return -ESTALE;
319         }
320
321         tty = priv->tty;
322
323         if (tty->ops->start)
324                 tty->ops->start(tty);
325         /* Make sure we can receive more data */
326         irtty_stop_receiver(tty, FALSE);
327
328         mutex_unlock(&irtty_mutex);
329         return 0;
330 }
331
332 /* notifier from sir_dev when irda% device gets closed (ifdown) */
333
334 static int irtty_stop_dev(struct sir_dev *dev)
335 {
336         struct sirtty_cb *priv;
337         struct tty_struct *tty;
338
339         /* serialize with ldisc open/close */
340         mutex_lock(&irtty_mutex);
341
342         priv = dev->priv;
343         if (unlikely(!priv || priv->magic!=IRTTY_MAGIC)) {
344                 mutex_unlock(&irtty_mutex);
345                 return -ESTALE;
346         }
347
348         tty = priv->tty;
349
350         /* Make sure we don't receive more data */
351         irtty_stop_receiver(tty, TRUE);
352         if (tty->ops->stop)
353                 tty->ops->stop(tty);
354
355         mutex_unlock(&irtty_mutex);
356
357         return 0;
358 }
359
360 /* ------------------------------------------------------- */
361
362 static struct sir_driver sir_tty_drv = {
363         .owner                  = THIS_MODULE,
364         .driver_name            = "sir_tty",
365         .start_dev              = irtty_start_dev,
366         .stop_dev               = irtty_stop_dev,
367         .do_write               = irtty_do_write,
368         .chars_in_buffer        = irtty_chars_in_buffer,
369         .wait_until_sent        = irtty_wait_until_sent,
370         .set_speed              = irtty_change_speed,
371         .set_dtr_rts            = irtty_set_dtr_rts,
372 };
373
374 /* ------------------------------------------------------- */
375
376 /*
377  * Function irtty_ioctl (tty, file, cmd, arg)
378  *
379  *     The Swiss army knife of system calls :-)
380  *
381  */
382 static int irtty_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
383 {
384         struct irtty_info { char name[6]; } info;
385         struct sir_dev *dev;
386         struct sirtty_cb *priv = tty->disc_data;
387         int err = 0;
388
389         IRDA_ASSERT(priv != NULL, return -ENODEV;);
390         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return -EBADR;);
391
392         IRDA_DEBUG(3, "%s(cmd=0x%X)\n", __func__, cmd);
393
394         dev = priv->dev;
395         IRDA_ASSERT(dev != NULL, return -1;);
396
397         switch (cmd) {
398         case IRTTY_IOCTDONGLE:
399                 /* this call blocks for completion */
400                 err = sirdev_set_dongle(dev, (IRDA_DONGLE) arg);
401                 break;
402
403         case IRTTY_IOCGET:
404                 IRDA_ASSERT(dev->netdev != NULL, return -1;);
405
406                 memset(&info, 0, sizeof(info)); 
407                 strncpy(info.name, dev->netdev->name, sizeof(info.name)-1);
408
409                 if (copy_to_user((void __user *)arg, &info, sizeof(info)))
410                         err = -EFAULT;
411                 break;
412         default:
413                 err = tty_mode_ioctl(tty, file, cmd, arg);
414                 break;
415         }
416         return err;
417 }
418
419
420 /* 
421  *  Function irtty_open(tty)
422  *
423  *    This function is called by the TTY module when the IrDA line
424  *    discipline is called for.  Because we are sure the tty line exists,
425  *    we only have to link it to a free IrDA channel.  
426  */
427 static int irtty_open(struct tty_struct *tty) 
428 {
429         struct sir_dev *dev;
430         struct sirtty_cb *priv;
431         int ret = 0;
432
433         /* Module stuff handled via irda_ldisc.owner - Jean II */
434
435         /* First make sure we're not already connected. */
436         if (tty->disc_data != NULL) {
437                 priv = tty->disc_data;
438                 if (priv && priv->magic == IRTTY_MAGIC) {
439                         ret = -EEXIST;
440                         goto out;
441                 }
442                 tty->disc_data = NULL;          /* ### */
443         }
444
445         /* stop the underlying  driver */
446         irtty_stop_receiver(tty, TRUE);
447         if (tty->ops->stop)
448                 tty->ops->stop(tty);
449
450         tty_driver_flush_buffer(tty);
451         
452         /* apply mtt override */
453         sir_tty_drv.qos_mtt_bits = qos_mtt_bits;
454
455         /* get a sir device instance for this driver */
456         dev = sirdev_get_instance(&sir_tty_drv, tty->name);
457         if (!dev) {
458                 ret = -ENODEV;
459                 goto out;
460         }
461
462         /* allocate private device info block */
463         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
464         if (!priv)
465                 goto out_put;
466
467         priv->magic = IRTTY_MAGIC;
468         priv->tty = tty;
469         priv->dev = dev;
470
471         /* serialize with start_dev - in case we were racing with ifup */
472         mutex_lock(&irtty_mutex);
473
474         dev->priv = priv;
475         tty->disc_data = priv;
476         tty->receive_room = 65536;
477
478         mutex_unlock(&irtty_mutex);
479
480         IRDA_DEBUG(0, "%s - %s: irda line discipline opened\n", __func__, tty->name);
481
482         return 0;
483
484 out_put:
485         sirdev_put_instance(dev);
486 out:
487         return ret;
488 }
489
490 /* 
491  *  Function irtty_close (tty)
492  *
493  *    Close down a IrDA channel. This means flushing out any pending queues,
494  *    and then restoring the TTY line discipline to what it was before it got
495  *    hooked to IrDA (which usually is TTY again).  
496  */
497 static void irtty_close(struct tty_struct *tty) 
498 {
499         struct sirtty_cb *priv = tty->disc_data;
500
501         IRDA_ASSERT(priv != NULL, return;);
502         IRDA_ASSERT(priv->magic == IRTTY_MAGIC, return;);
503
504         /* Hm, with a dongle attached the dongle driver wants
505          * to close the dongle - which requires the use of
506          * some tty write and/or termios or ioctl operations.
507          * Are we allowed to call those when already requested
508          * to shutdown the ldisc?
509          * If not, we should somehow mark the dev being staled.
510          * Question remains, how to close the dongle in this case...
511          * For now let's assume we are granted to issue tty driver calls
512          * until we return here from the ldisc close. I'm just wondering
513          * how this behaves with hotpluggable serial hardware like
514          * rs232-pcmcia card or usb-serial...
515          *
516          * priv->tty = NULL?;
517          */
518
519         /* we are dead now */
520         tty->disc_data = NULL;
521
522         sirdev_put_instance(priv->dev);
523
524         /* Stop tty */
525         irtty_stop_receiver(tty, TRUE);
526         clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
527         if (tty->ops->stop)
528                 tty->ops->stop(tty);
529
530         kfree(priv);
531
532         IRDA_DEBUG(0, "%s - %s: irda line discipline closed\n", __func__, tty->name);
533 }
534
535 /* ------------------------------------------------------- */
536
537 static struct tty_ldisc_ops irda_ldisc = {
538         .magic          = TTY_LDISC_MAGIC,
539         .name           = "irda",
540         .flags          = 0,
541         .open           = irtty_open,
542         .close          = irtty_close,
543         .read           = NULL,
544         .write          = NULL,
545         .ioctl          = irtty_ioctl,
546         .poll           = NULL,
547         .receive_buf    = irtty_receive_buf,
548         .write_wakeup   = irtty_write_wakeup,
549         .owner          = THIS_MODULE,
550 };
551
552 /* ------------------------------------------------------- */
553
554 static int __init irtty_sir_init(void)
555 {
556         int err;
557
558         if ((err = tty_register_ldisc(N_IRDA, &irda_ldisc)) != 0)
559                 IRDA_ERROR("IrDA: can't register line discipline (err = %d)\n",
560                            err);
561         return err;
562 }
563
564 static void __exit irtty_sir_cleanup(void) 
565 {
566         int err;
567
568         if ((err = tty_unregister_ldisc(N_IRDA))) {
569                 IRDA_ERROR("%s(), can't unregister line discipline (err = %d)\n",
570                            __func__, err);
571         }
572 }
573
574 module_init(irtty_sir_init);
575 module_exit(irtty_sir_cleanup);
576
577 MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
578 MODULE_DESCRIPTION("IrDA TTY device driver");
579 MODULE_ALIAS_LDISC(N_IRDA);
580 MODULE_LICENSE("GPL");
581