1 /*********************************************************************
3 * Filename: irtty-sir.c
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>
14 * Copyright (c) 1998-2000 Dag Brattli,
15 * Copyright (c) 2002 Martin Diehl,
16 * All Rights Reserved.
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.
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.
27 ********************************************************************/
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/smp_lock.h>
35 #include <linux/delay.h>
37 #include <net/irda/irda.h>
38 #include <net/irda/irda_device.h>
41 #include "irtty-sir.h"
43 static int qos_mtt_bits
= 0x03; /* 5 ms or more */
45 module_param(qos_mtt_bits
, int, 0);
46 MODULE_PARM_DESC(qos_mtt_bits
, "Minimum Turn Time");
48 /* ------------------------------------------------------- */
50 /* device configuration callbacks always invoked with irda-thread context */
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()
59 static int irtty_chars_in_buffer(struct sir_dev
*dev
)
61 struct sirtty_cb
*priv
= dev
->priv
;
63 IRDA_ASSERT(priv
!= NULL
, return -1;);
64 IRDA_ASSERT(priv
->magic
== IRTTY_MAGIC
, return -1;);
66 return priv
->tty
->driver
->chars_in_buffer(priv
->tty
);
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
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
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.
80 * I really wish all serial drivers would provide
81 * correct implementation of wait_until_sent()
84 #define USBSERIAL_TX_DONE_DELAY 60
86 static void irtty_wait_until_sent(struct sir_dev
*dev
)
88 struct sirtty_cb
*priv
= dev
->priv
;
89 struct tty_struct
*tty
;
91 IRDA_ASSERT(priv
!= NULL
, return;);
92 IRDA_ASSERT(priv
->magic
== IRTTY_MAGIC
, return;);
95 if (tty
->driver
->wait_until_sent
) {
97 tty
->driver
->wait_until_sent(tty
, msecs_to_jiffies(100));
101 msleep(USBSERIAL_TX_DONE_DELAY
);
106 * Function irtty_change_speed (dev, speed)
108 * Change the speed of the serial port.
110 * This may sleep in set_termios (usbserial driver f.e.) and must
111 * not be called from interrupt/timer/tasklet therefore.
112 * All such invocations are deferred to kIrDAd now so we can sleep there.
115 static int irtty_change_speed(struct sir_dev
*dev
, unsigned speed
)
117 struct sirtty_cb
*priv
= dev
->priv
;
118 struct tty_struct
*tty
;
119 struct termios old_termios
;
122 IRDA_ASSERT(priv
!= NULL
, return -1;);
123 IRDA_ASSERT(priv
->magic
== IRTTY_MAGIC
, return -1;);
128 old_termios
= *(tty
->termios
);
129 cflag
= tty
->termios
->c_cflag
;
133 IRDA_DEBUG(2, "%s(), Setting speed to %d\n", __FUNCTION__
, speed
);
163 tty
->termios
->c_cflag
= cflag
;
164 if (tty
->driver
->set_termios
)
165 tty
->driver
->set_termios(tty
, &old_termios
);
168 priv
->io
.speed
= speed
;
174 * Function irtty_set_dtr_rts (dev, dtr, rts)
176 * This function can be used by dongles etc. to set or reset the status
177 * of the dtr and rts lines
180 static int irtty_set_dtr_rts(struct sir_dev
*dev
, int dtr
, int rts
)
182 struct sirtty_cb
*priv
= dev
->priv
;
186 IRDA_ASSERT(priv
!= NULL
, return -1;);
187 IRDA_ASSERT(priv
->magic
== IRTTY_MAGIC
, return -1;);
199 * We can't use ioctl() because it expects a non-null file structure,
200 * and we don't have that here.
201 * This function is not yet defined for all tty driver, so
202 * let's be careful... Jean II
204 IRDA_ASSERT(priv
->tty
->driver
->tiocmset
!= NULL
, return -1;);
205 priv
->tty
->driver
->tiocmset(priv
->tty
, NULL
, set
, clear
);
210 /* ------------------------------------------------------- */
212 /* called from sir_dev when there is more data to send
213 * context is either netdev->hard_xmit or some transmit-completion bh
214 * i.e. we are under spinlock here and must not sleep.
217 static int irtty_do_write(struct sir_dev
*dev
, const unsigned char *ptr
, size_t len
)
219 struct sirtty_cb
*priv
= dev
->priv
;
220 struct tty_struct
*tty
;
223 IRDA_ASSERT(priv
!= NULL
, return -1;);
224 IRDA_ASSERT(priv
->magic
== IRTTY_MAGIC
, return -1;);
227 if (!tty
->driver
->write
)
229 tty
->flags
|= (1 << TTY_DO_WRITE_WAKEUP
);
230 if (tty
->driver
->write_room
) {
231 writelen
= tty
->driver
->write_room(tty
);
237 return tty
->driver
->write(tty
, ptr
, writelen
);
240 /* ------------------------------------------------------- */
242 /* irda line discipline callbacks */
245 * Function irtty_receive_buf( tty, cp, count)
247 * Handle the 'receiver data ready' interrupt. This function is called
248 * by the 'tty_io' module in the kernel when a block of IrDA data has
249 * been received, which can now be decapsulated and delivered for
252 * calling context depends on underlying driver and tty->low_latency!
253 * for example (low_latency: 1 / 0):
254 * serial.c: uart-interrupt / softint
255 * usbserial: urb-complete-interrupt / softint
258 static void irtty_receive_buf(struct tty_struct
*tty
, const unsigned char *cp
,
262 struct sirtty_cb
*priv
= tty
->disc_data
;
265 IRDA_ASSERT(priv
!= NULL
, return;);
266 IRDA_ASSERT(priv
->magic
== IRTTY_MAGIC
, return;);
268 if (unlikely(count
==0)) /* yes, this happens */
273 IRDA_WARNING("%s(), not ready yet!\n", __FUNCTION__
);
277 for (i
= 0; i
< count
; i
++) {
279 * Characters received with a parity error, etc?
282 IRDA_DEBUG(0, "Framing or parity error!\n");
283 sirdev_receive(dev
, NULL
, 0); /* notify sir_dev (updating stats) */
288 sirdev_receive(dev
, cp
, count
);
292 * Function irtty_write_wakeup (tty)
294 * Called by the driver when there's room for more data. If we have
295 * more packets to send, we send them here.
298 static void irtty_write_wakeup(struct tty_struct
*tty
)
300 struct sirtty_cb
*priv
= tty
->disc_data
;
302 IRDA_ASSERT(priv
!= NULL
, return;);
303 IRDA_ASSERT(priv
->magic
== IRTTY_MAGIC
, return;);
305 tty
->flags
&= ~(1 << TTY_DO_WRITE_WAKEUP
);
308 sirdev_write_complete(priv
->dev
);
311 /* ------------------------------------------------------- */
314 * Function irtty_stop_receiver (tty, stop)
318 static inline void irtty_stop_receiver(struct tty_struct
*tty
, int stop
)
320 struct termios old_termios
;
324 old_termios
= *(tty
->termios
);
325 cflag
= tty
->termios
->c_cflag
;
332 tty
->termios
->c_cflag
= cflag
;
333 if (tty
->driver
->set_termios
)
334 tty
->driver
->set_termios(tty
, &old_termios
);
338 /*****************************************************************/
340 /* serialize ldisc open/close with sir_dev */
341 static DECLARE_MUTEX(irtty_sem
);
343 /* notifier from sir_dev when irda% device gets opened (ifup) */
345 static int irtty_start_dev(struct sir_dev
*dev
)
347 struct sirtty_cb
*priv
;
348 struct tty_struct
*tty
;
350 /* serialize with ldisc open/close */
354 if (unlikely(!priv
|| priv
->magic
!=IRTTY_MAGIC
)) {
361 if (tty
->driver
->start
)
362 tty
->driver
->start(tty
);
363 /* Make sure we can receive more data */
364 irtty_stop_receiver(tty
, FALSE
);
370 /* notifier from sir_dev when irda% device gets closed (ifdown) */
372 static int irtty_stop_dev(struct sir_dev
*dev
)
374 struct sirtty_cb
*priv
;
375 struct tty_struct
*tty
;
377 /* serialize with ldisc open/close */
381 if (unlikely(!priv
|| priv
->magic
!=IRTTY_MAGIC
)) {
388 /* Make sure we don't receive more data */
389 irtty_stop_receiver(tty
, TRUE
);
390 if (tty
->driver
->stop
)
391 tty
->driver
->stop(tty
);
398 /* ------------------------------------------------------- */
400 static struct sir_driver sir_tty_drv
= {
401 .owner
= THIS_MODULE
,
402 .driver_name
= "sir_tty",
403 .start_dev
= irtty_start_dev
,
404 .stop_dev
= irtty_stop_dev
,
405 .do_write
= irtty_do_write
,
406 .chars_in_buffer
= irtty_chars_in_buffer
,
407 .wait_until_sent
= irtty_wait_until_sent
,
408 .set_speed
= irtty_change_speed
,
409 .set_dtr_rts
= irtty_set_dtr_rts
,
412 /* ------------------------------------------------------- */
415 * Function irtty_ioctl (tty, file, cmd, arg)
417 * The Swiss army knife of system calls :-)
420 static int irtty_ioctl(struct tty_struct
*tty
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
422 struct irtty_info
{ char name
[6]; } info
;
424 struct sirtty_cb
*priv
= tty
->disc_data
;
427 IRDA_ASSERT(priv
!= NULL
, return -ENODEV
;);
428 IRDA_ASSERT(priv
->magic
== IRTTY_MAGIC
, return -EBADR
;);
430 IRDA_DEBUG(3, "%s(cmd=0x%X)\n", __FUNCTION__
, cmd
);
433 IRDA_ASSERT(dev
!= NULL
, return -1;);
438 err
= n_tty_ioctl(tty
, file
, cmd
, arg
);
441 case IRTTY_IOCTDONGLE
:
442 /* this call blocks for completion */
443 err
= sirdev_set_dongle(dev
, (IRDA_DONGLE
) arg
);
447 IRDA_ASSERT(dev
->netdev
!= NULL
, return -1;);
449 memset(&info
, 0, sizeof(info
));
450 strncpy(info
.name
, dev
->netdev
->name
, sizeof(info
.name
)-1);
452 if (copy_to_user((void __user
*)arg
, &info
, sizeof(info
)))
464 * Function irtty_open(tty)
466 * This function is called by the TTY module when the IrDA line
467 * discipline is called for. Because we are sure the tty line exists,
468 * we only have to link it to a free IrDA channel.
470 static int irtty_open(struct tty_struct
*tty
)
473 struct sirtty_cb
*priv
;
476 /* Module stuff handled via irda_ldisc.owner - Jean II */
478 /* First make sure we're not already connected. */
479 if (tty
->disc_data
!= NULL
) {
480 priv
= tty
->disc_data
;
481 if (priv
&& priv
->magic
== IRTTY_MAGIC
) {
485 tty
->disc_data
= NULL
; /* ### */
488 /* stop the underlying driver */
489 irtty_stop_receiver(tty
, TRUE
);
490 if (tty
->driver
->stop
)
491 tty
->driver
->stop(tty
);
493 if (tty
->driver
->flush_buffer
)
494 tty
->driver
->flush_buffer(tty
);
496 /* apply mtt override */
497 sir_tty_drv
.qos_mtt_bits
= qos_mtt_bits
;
499 /* get a sir device instance for this driver */
500 dev
= sirdev_get_instance(&sir_tty_drv
, tty
->name
);
506 /* allocate private device info block */
507 priv
= kmalloc(sizeof(*priv
), GFP_KERNEL
);
510 memset(priv
, 0, sizeof(*priv
));
512 priv
->magic
= IRTTY_MAGIC
;
516 /* serialize with start_dev - in case we were racing with ifup */
520 tty
->disc_data
= priv
;
521 tty
->receive_room
= 65536;
525 IRDA_DEBUG(0, "%s - %s: irda line discipline opened\n", __FUNCTION__
, tty
->name
);
530 sirdev_put_instance(dev
);
536 * Function irtty_close (tty)
538 * Close down a IrDA channel. This means flushing out any pending queues,
539 * and then restoring the TTY line discipline to what it was before it got
540 * hooked to IrDA (which usually is TTY again).
542 static void irtty_close(struct tty_struct
*tty
)
544 struct sirtty_cb
*priv
= tty
->disc_data
;
546 IRDA_ASSERT(priv
!= NULL
, return;);
547 IRDA_ASSERT(priv
->magic
== IRTTY_MAGIC
, return;);
549 /* Hm, with a dongle attached the dongle driver wants
550 * to close the dongle - which requires the use of
551 * some tty write and/or termios or ioctl operations.
552 * Are we allowed to call those when already requested
553 * to shutdown the ldisc?
554 * If not, we should somehow mark the dev being staled.
555 * Question remains, how to close the dongle in this case...
556 * For now let's assume we are granted to issue tty driver calls
557 * until we return here from the ldisc close. I'm just wondering
558 * how this behaves with hotpluggable serial hardware like
559 * rs232-pcmcia card or usb-serial...
564 /* we are dead now */
565 tty
->disc_data
= NULL
;
567 sirdev_put_instance(priv
->dev
);
570 irtty_stop_receiver(tty
, TRUE
);
571 tty
->flags
&= ~(1 << TTY_DO_WRITE_WAKEUP
);
572 if (tty
->driver
->stop
)
573 tty
->driver
->stop(tty
);
577 IRDA_DEBUG(0, "%s - %s: irda line discipline closed\n", __FUNCTION__
, tty
->name
);
580 /* ------------------------------------------------------- */
582 static struct tty_ldisc irda_ldisc
= {
583 .magic
= TTY_LDISC_MAGIC
,
587 .close
= irtty_close
,
590 .ioctl
= irtty_ioctl
,
592 .receive_buf
= irtty_receive_buf
,
593 .write_wakeup
= irtty_write_wakeup
,
594 .owner
= THIS_MODULE
,
597 /* ------------------------------------------------------- */
599 static int __init
irtty_sir_init(void)
603 if ((err
= tty_register_ldisc(N_IRDA
, &irda_ldisc
)) != 0)
604 IRDA_ERROR("IrDA: can't register line discipline (err = %d)\n",
609 static void __exit
irtty_sir_cleanup(void)
613 if ((err
= tty_unregister_ldisc(N_IRDA
))) {
614 IRDA_ERROR("%s(), can't unregister line discipline (err = %d)\n",
619 module_init(irtty_sir_init
);
620 module_exit(irtty_sir_cleanup
);
622 MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
623 MODULE_DESCRIPTION("IrDA TTY device driver");
624 MODULE_ALIAS_LDISC(N_IRDA
);
625 MODULE_LICENSE("GPL");
This page took 0.056626 seconds and 6 git commands to generate.