1 /*********************************************************************
3 * Filename: ircomm_tty.c
5 * Description: IrCOMM serial TTY driver
6 * Status: Experimental.
7 * Author: Dag Brattli <dagb@cs.uit.no>
8 * Created at: Sun Jun 6 21:00:56 1999
9 * Modified at: Wed Feb 23 00:09:02 2000
10 * Modified by: Dag Brattli <dagb@cs.uit.no>
11 * Sources: serial.c and previous IrCOMM work by Takahide Higuchi
13 * Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
14 * Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
16 * This program is free software; you can redistribute it and/or
17 * modify it under the terms of the GNU General Public License as
18 * published by the Free Software Foundation; either version 2 of
19 * the License, or (at your option) any later version.
21 * This program is distributed in the hope that it will be useful,
22 * but WITHOUT ANY WARRANTY; without even the implied warranty of
23 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
24 * GNU General Public License for more details.
26 * You should have received a copy of the GNU General Public License
27 * along with this program; if not, write to the Free Software
28 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
31 ********************************************************************/
33 #include <linux/config.h>
34 #include <linux/init.h>
35 #include <linux/module.h>
37 #include <linux/sched.h>
38 #include <linux/termios.h>
39 #include <linux/tty.h>
40 #include <linux/interrupt.h>
41 #include <linux/device.h> /* for MODULE_ALIAS_CHARDEV_MAJOR */
43 #include <asm/uaccess.h>
45 #include <net/irda/irda.h>
46 #include <net/irda/irmod.h>
48 #include <net/irda/ircomm_core.h>
49 #include <net/irda/ircomm_param.h>
50 #include <net/irda/ircomm_tty_attach.h>
51 #include <net/irda/ircomm_tty.h>
53 static int ircomm_tty_open(struct tty_struct *tty, struct file *filp);
54 static void ircomm_tty_close(struct tty_struct * tty, struct file *filp);
55 static int ircomm_tty_write(struct tty_struct * tty, int from_user,
56 const unsigned char *buf, int count);
57 static int ircomm_tty_write_room(struct tty_struct *tty);
58 static void ircomm_tty_throttle(struct tty_struct *tty);
59 static void ircomm_tty_unthrottle(struct tty_struct *tty);
60 static int ircomm_tty_chars_in_buffer(struct tty_struct *tty);
61 static void ircomm_tty_flush_buffer(struct tty_struct *tty);
62 static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch);
63 static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout);
64 static void ircomm_tty_hangup(struct tty_struct *tty);
65 static void ircomm_tty_do_softint(void *private_);
66 static void ircomm_tty_shutdown(struct ircomm_tty_cb *self);
68 static int ircomm_tty_data_indication(void *instance, void *sap,
70 static int ircomm_tty_control_indication(void *instance, void *sap,
72 static void ircomm_tty_flow_indication(void *instance, void *sap,
75 static int ircomm_tty_read_proc(char *buf, char **start, off_t offset, int len,
76 int *eof, void *unused);
77 #endif /* CONFIG_PROC_FS */
78 static struct tty_driver *driver;
80 hashbin_t *ircomm_tty = NULL;
82 static struct tty_operations ops = {
83 .open = ircomm_tty_open,
84 .close = ircomm_tty_close,
85 .write = ircomm_tty_write,
86 .write_room = ircomm_tty_write_room,
87 .chars_in_buffer = ircomm_tty_chars_in_buffer,
88 .flush_buffer = ircomm_tty_flush_buffer,
89 .ioctl = ircomm_tty_ioctl, /* ircomm_tty_ioctl.c */
90 .tiocmget = ircomm_tty_tiocmget, /* ircomm_tty_ioctl.c */
91 .tiocmset = ircomm_tty_tiocmset, /* ircomm_tty_ioctl.c */
92 .throttle = ircomm_tty_throttle,
93 .unthrottle = ircomm_tty_unthrottle,
94 .send_xchar = ircomm_tty_send_xchar,
95 .set_termios = ircomm_tty_set_termios,
96 .stop = ircomm_tty_stop,
97 .start = ircomm_tty_start,
98 .hangup = ircomm_tty_hangup,
99 .wait_until_sent = ircomm_tty_wait_until_sent,
100 #ifdef CONFIG_PROC_FS
101 .read_proc = ircomm_tty_read_proc,
102 #endif /* CONFIG_PROC_FS */
106 * Function ircomm_tty_init()
108 * Init IrCOMM TTY layer/driver
111 int __init ircomm_tty_init(void)
113 driver = alloc_tty_driver(IRCOMM_TTY_PORTS);
116 ircomm_tty = hashbin_new(HB_LOCK);
117 if (ircomm_tty == NULL) {
118 ERROR("%s(), can't allocate hashbin!\n", __FUNCTION__);
119 put_tty_driver(driver);
123 driver->owner = THIS_MODULE;
124 driver->driver_name = "ircomm";
125 driver->name = "ircomm";
126 driver->devfs_name = "ircomm";
127 driver->major = IRCOMM_TTY_MAJOR;
128 driver->minor_start = IRCOMM_TTY_MINOR;
129 driver->type = TTY_DRIVER_TYPE_SERIAL;
130 driver->subtype = SERIAL_TYPE_NORMAL;
131 driver->init_termios = tty_std_termios;
132 driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
133 driver->flags = TTY_DRIVER_REAL_RAW;
134 tty_set_operations(driver, &ops);
135 if (tty_register_driver(driver)) {
136 ERROR("%s(): Couldn't register serial driver\n", __FUNCTION__);
137 put_tty_driver(driver);
143 static void __exit __ircomm_tty_cleanup(struct ircomm_tty_cb *self)
145 IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
147 ASSERT(self != NULL, return;);
148 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
150 ircomm_tty_shutdown(self);
157 * Function ircomm_tty_cleanup ()
159 * Remove IrCOMM TTY layer/driver
162 void __exit ircomm_tty_cleanup(void)
166 IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
168 ret = tty_unregister_driver(driver);
170 ERROR("%s(), failed to unregister driver\n", __FUNCTION__);
174 hashbin_delete(ircomm_tty, (FREE_FUNC) __ircomm_tty_cleanup);
175 put_tty_driver(driver);
179 * Function ircomm_startup (self)
184 static int ircomm_tty_startup(struct ircomm_tty_cb *self)
189 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
191 ASSERT(self != NULL, return -1;);
192 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
194 /* Check if already open */
195 if (test_and_set_bit(ASYNC_B_INITIALIZED, &self->flags)) {
196 IRDA_DEBUG(2, "%s(), already open so break out!\n", __FUNCTION__ );
200 /* Register with IrCOMM */
201 irda_notify_init(¬ify);
202 /* These callbacks we must handle ourselves */
203 notify.data_indication = ircomm_tty_data_indication;
204 notify.udata_indication = ircomm_tty_control_indication;
205 notify.flow_indication = ircomm_tty_flow_indication;
207 /* Use the ircomm_tty interface for these ones */
208 notify.disconnect_indication = ircomm_tty_disconnect_indication;
209 notify.connect_confirm = ircomm_tty_connect_confirm;
210 notify.connect_indication = ircomm_tty_connect_indication;
211 strlcpy(notify.name, "ircomm_tty", sizeof(notify.name));
212 notify.instance = self;
215 self->ircomm = ircomm_open(¬ify, self->service_type,
221 self->slsap_sel = self->ircomm->slsap_sel;
223 /* Connect IrCOMM link with remote device */
224 ret = ircomm_tty_attach_cable(self);
226 ERROR("%s(), error attaching cable!\n", __FUNCTION__);
232 clear_bit(ASYNC_B_INITIALIZED, &self->flags);
237 * Function ircomm_block_til_ready (self, filp)
242 static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self,
245 DECLARE_WAITQUEUE(wait, current);
247 int do_clocal = 0, extra_count = 0;
249 struct tty_struct *tty;
251 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
256 * If non-blocking mode is set, or the port is not enabled,
257 * then make the check up front and then exit.
259 if (filp->f_flags & O_NONBLOCK || tty->flags & (1 << TTY_IO_ERROR)){
260 /* nonblock mode is set or port is not enabled */
261 self->flags |= ASYNC_NORMAL_ACTIVE;
262 IRDA_DEBUG(1, "%s(), O_NONBLOCK requested!\n", __FUNCTION__ );
266 if (tty->termios->c_cflag & CLOCAL) {
267 IRDA_DEBUG(1, "%s(), doing CLOCAL!\n", __FUNCTION__ );
271 /* Wait for carrier detect and the line to become
272 * free (i.e., not in use by the callout). While we are in
273 * this loop, self->open_count is dropped by one, so that
274 * mgsl_close() knows when to free things. We restore it upon
275 * exit, either normal or abnormal.
279 add_wait_queue(&self->open_wait, &wait);
281 IRDA_DEBUG(2, "%s(%d):block_til_ready before block on %s open_count=%d\n",
282 __FILE__,__LINE__, tty->driver->name, self->open_count );
284 /* As far as I can see, we protect open_count - Jean II */
285 spin_lock_irqsave(&self->spinlock, flags);
286 if (!tty_hung_up_p(filp)) {
290 spin_unlock_irqrestore(&self->spinlock, flags);
291 self->blocked_open++;
294 if (tty->termios->c_cflag & CBAUD) {
295 /* Here, we use to lock those two guys, but
296 * as ircomm_param_request() does it itself,
297 * I don't see the point (and I see the deadlock).
299 self->settings.dte |= IRCOMM_RTS + IRCOMM_DTR;
301 ircomm_param_request(self, IRCOMM_DTE, TRUE);
304 current->state = TASK_INTERRUPTIBLE;
306 if (tty_hung_up_p(filp) ||
307 !test_bit(ASYNC_B_INITIALIZED, &self->flags)) {
308 retval = (self->flags & ASYNC_HUP_NOTIFY) ?
309 -EAGAIN : -ERESTARTSYS;
314 * Check if link is ready now. Even if CLOCAL is
315 * specified, we cannot return before the IrCOMM link is
318 if (!test_bit(ASYNC_B_CLOSING, &self->flags) &&
319 (do_clocal || (self->settings.dce & IRCOMM_CD)) &&
320 self->state == IRCOMM_TTY_READY)
325 if (signal_pending(current)) {
326 retval = -ERESTARTSYS;
330 IRDA_DEBUG(1, "%s(%d):block_til_ready blocking on %s open_count=%d\n",
331 __FILE__,__LINE__, tty->driver->name, self->open_count );
336 __set_current_state(TASK_RUNNING);
337 remove_wait_queue(&self->open_wait, &wait);
340 /* ++ is not atomic, so this should be protected - Jean II */
341 spin_lock_irqsave(&self->spinlock, flags);
343 spin_unlock_irqrestore(&self->spinlock, flags);
345 self->blocked_open--;
347 IRDA_DEBUG(1, "%s(%d):block_til_ready after blocking on %s open_count=%d\n",
348 __FILE__,__LINE__, tty->driver->name, self->open_count);
351 self->flags |= ASYNC_NORMAL_ACTIVE;
357 * Function ircomm_tty_open (tty, filp)
359 * This routine is called when a particular tty device is opened. This
360 * routine is mandatory; if this routine is not filled in, the attempted
361 * open will fail with ENODEV.
363 static int ircomm_tty_open(struct tty_struct *tty, struct file *filp)
365 struct ircomm_tty_cb *self;
370 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
373 if ((line < 0) || (line >= IRCOMM_TTY_PORTS)) {
377 /* Check if instance already exists */
378 self = hashbin_lock_find(ircomm_tty, line, NULL);
380 /* No, so make new instance */
381 self = kmalloc(sizeof(struct ircomm_tty_cb), GFP_KERNEL);
383 ERROR("%s(), kmalloc failed!\n", __FUNCTION__);
386 memset(self, 0, sizeof(struct ircomm_tty_cb));
388 self->magic = IRCOMM_TTY_MAGIC;
389 self->flow = FLOW_STOP;
392 INIT_WORK(&self->tqueue, ircomm_tty_do_softint, self);
393 self->max_header_size = IRCOMM_TTY_HDR_UNINITIALISED;
394 self->max_data_size = IRCOMM_TTY_DATA_UNINITIALISED;
395 self->close_delay = 5*HZ/10;
396 self->closing_wait = 30*HZ;
398 /* Init some important stuff */
399 init_timer(&self->watchdog_timer);
400 init_waitqueue_head(&self->open_wait);
401 init_waitqueue_head(&self->close_wait);
402 spin_lock_init(&self->spinlock);
405 * Force TTY into raw mode by default which is usually what
406 * we want for IrCOMM and IrLPT. This way applications will
407 * not have to twiddle with printcap etc.
409 tty->termios->c_iflag = 0;
410 tty->termios->c_oflag = 0;
412 /* Insert into hash */
413 hashbin_insert(ircomm_tty, (irda_queue_t *) self, line, NULL);
415 /* ++ is not atomic, so this should be protected - Jean II */
416 spin_lock_irqsave(&self->spinlock, flags);
419 tty->driver_data = self;
421 spin_unlock_irqrestore(&self->spinlock, flags);
423 IRDA_DEBUG(1, "%s(), %s%d, count = %d\n", __FUNCTION__ , tty->driver->name,
424 self->line, self->open_count);
426 /* Not really used by us, but lets do it anyway */
427 self->tty->low_latency = (self->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
430 * If the port is the middle of closing, bail out now
432 if (tty_hung_up_p(filp) ||
433 test_bit(ASYNC_B_CLOSING, &self->flags)) {
435 /* Hm, why are we blocking on ASYNC_CLOSING if we
436 * do return -EAGAIN/-ERESTARTSYS below anyway?
437 * IMHO it's either not needed in the first place
438 * or for some reason we need to make sure the async
439 * closing has been finished - if so, wouldn't we
440 * probably better sleep uninterruptible?
443 if (wait_event_interruptible(self->close_wait, !test_bit(ASYNC_B_CLOSING, &self->flags))) {
444 WARNING("%s - got signal while blocking on ASYNC_CLOSING!\n",
449 #ifdef SERIAL_DO_RESTART
450 return ((self->flags & ASYNC_HUP_NOTIFY) ?
451 -EAGAIN : -ERESTARTSYS);
457 /* Check if this is a "normal" ircomm device, or an irlpt device */
459 self->service_type = IRCOMM_3_WIRE | IRCOMM_9_WIRE;
460 self->settings.service_type = IRCOMM_9_WIRE; /* 9 wire as default */
461 /* Jan Kiszka -> add DSR/RI -> Conform to IrCOMM spec */
462 self->settings.dce = IRCOMM_CTS | IRCOMM_CD | IRCOMM_DSR | IRCOMM_RI; /* Default line settings */
463 IRDA_DEBUG(2, "%s(), IrCOMM device\n", __FUNCTION__ );
465 IRDA_DEBUG(2, "%s(), IrLPT device\n", __FUNCTION__ );
466 self->service_type = IRCOMM_3_WIRE_RAW;
467 self->settings.service_type = IRCOMM_3_WIRE_RAW; /* Default */
470 ret = ircomm_tty_startup(self);
474 ret = ircomm_tty_block_til_ready(self, filp);
477 "%s(), returning after block_til_ready with %d\n", __FUNCTION__ ,
486 * Function ircomm_tty_close (tty, filp)
488 * This routine is called when a particular tty device is closed.
491 static void ircomm_tty_close(struct tty_struct *tty, struct file *filp)
493 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
496 IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
501 ASSERT(self != NULL, return;);
502 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
504 spin_lock_irqsave(&self->spinlock, flags);
506 if (tty_hung_up_p(filp)) {
507 spin_unlock_irqrestore(&self->spinlock, flags);
509 IRDA_DEBUG(0, "%s(), returning 1\n", __FUNCTION__ );
513 if ((tty->count == 1) && (self->open_count != 1)) {
515 * Uh, oh. tty->count is 1, which means that the tty
516 * structure will be freed. state->count should always
517 * be one in these conditions. If it's greater than
518 * one, we've got real problems, since it means the
519 * serial port won't be shutdown.
521 IRDA_DEBUG(0, "%s(), bad serial port count; "
522 "tty->count is 1, state->count is %d\n", __FUNCTION__ ,
524 self->open_count = 1;
527 if (--self->open_count < 0) {
528 ERROR("%s(), bad serial port count for ttys%d: %d\n",
529 __FUNCTION__, self->line, self->open_count);
530 self->open_count = 0;
532 if (self->open_count) {
533 spin_unlock_irqrestore(&self->spinlock, flags);
535 IRDA_DEBUG(0, "%s(), open count > 0\n", __FUNCTION__ );
539 /* Hum... Should be test_and_set_bit ??? - Jean II */
540 set_bit(ASYNC_B_CLOSING, &self->flags);
542 /* We need to unlock here (we were unlocking at the end of this
543 * function), because tty_wait_until_sent() may schedule.
544 * I don't know if the rest should be protected somehow,
545 * so someone should check. - Jean II */
546 spin_unlock_irqrestore(&self->spinlock, flags);
549 * Now we wait for the transmit buffer to clear; and we notify
550 * the line discipline to only process XON/XOFF characters.
553 if (self->closing_wait != ASYNC_CLOSING_WAIT_NONE)
554 tty_wait_until_sent(tty, self->closing_wait);
556 ircomm_tty_shutdown(self);
558 if (tty->driver->flush_buffer)
559 tty->driver->flush_buffer(tty);
560 if (tty->ldisc.flush_buffer)
561 tty->ldisc.flush_buffer(tty);
566 if (self->blocked_open) {
567 if (self->close_delay) {
568 current->state = TASK_INTERRUPTIBLE;
569 schedule_timeout(self->close_delay);
571 wake_up_interruptible(&self->open_wait);
574 self->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CLOSING);
575 wake_up_interruptible(&self->close_wait);
579 * Function ircomm_tty_flush_buffer (tty)
584 static void ircomm_tty_flush_buffer(struct tty_struct *tty)
586 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
588 ASSERT(self != NULL, return;);
589 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
592 * Let do_softint() do this to avoid race condition with
595 schedule_work(&self->tqueue);
599 * Function ircomm_tty_do_softint (private_)
601 * We use this routine to give the write wakeup to the user at at a
602 * safe time (as fast as possible after write have completed). This
603 * can be compared to the Tx interrupt.
605 static void ircomm_tty_do_softint(void *private_)
607 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) private_;
608 struct tty_struct *tty;
610 struct sk_buff *skb, *ctrl_skb;
612 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
614 if (!self || self->magic != IRCOMM_TTY_MAGIC)
621 /* Unlink control buffer */
622 spin_lock_irqsave(&self->spinlock, flags);
624 ctrl_skb = self->ctrl_skb;
625 self->ctrl_skb = NULL;
627 spin_unlock_irqrestore(&self->spinlock, flags);
629 /* Flush control buffer if any */
631 if(self->flow == FLOW_START)
632 ircomm_control_request(self->ircomm, ctrl_skb);
633 /* Drop reference count - see ircomm_ttp_data_request(). */
634 dev_kfree_skb(ctrl_skb);
640 /* Unlink transmit buffer */
641 spin_lock_irqsave(&self->spinlock, flags);
646 spin_unlock_irqrestore(&self->spinlock, flags);
648 /* Flush transmit buffer if any */
650 ircomm_tty_do_event(self, IRCOMM_TTY_DATA_REQUEST, skb, NULL);
651 /* Drop reference count - see ircomm_ttp_data_request(). */
655 /* Check if user (still) wants to be waken up */
656 if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
657 tty->ldisc.write_wakeup)
659 (tty->ldisc.write_wakeup)(tty);
661 wake_up_interruptible(&tty->write_wait);
665 * Function ircomm_tty_write (tty, from_user, buf, count)
667 * This routine is called by the kernel to write a series of characters
668 * to the tty device. The characters may come from user space or kernel
669 * space. This routine will return the number of characters actually
670 * accepted for writing. This routine is mandatory.
672 static int ircomm_tty_write(struct tty_struct *tty, int from_user,
673 const unsigned char *ubuf, int count)
675 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
676 unsigned char *kbuf; /* Buffer in kernel space */
683 IRDA_DEBUG(2, "%s(), count=%d, hw_stopped=%d\n", __FUNCTION__ , count,
686 ASSERT(self != NULL, return -1;);
687 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
689 /* We may receive packets from the TTY even before we have finished
690 * our setup. Not cool.
691 * The problem is that we don't know the final header and data size
692 * to create the proper skb, so any skb we would create would have
693 * bogus header and data size, so need care.
694 * We use a bogus header size to safely detect this condition.
695 * Another problem is that hw_stopped was set to 0 way before it
696 * should be, so we would drop this skb. It should now be fixed.
697 * One option is to not accept data until we are properly setup.
698 * But, I suspect that when it happens, the ppp line discipline
699 * just "drops" the data, which might screw up connect scripts.
700 * The second option is to create a "safe skb", with large header
701 * and small size (see ircomm_tty_open() for values).
702 * We just need to make sure that when the real values get filled,
703 * we don't mess up the original "safe skb" (see tx_data_size).
705 if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED) {
706 IRDA_DEBUG(1, "%s() : not initialised\n", __FUNCTION__);
707 #ifdef IRCOMM_NO_TX_BEFORE_INIT
708 /* We didn't consume anything, TTY will retry */
716 /* Additional copy to avoid copy_from_user() under spinlock.
717 * We tradeoff this extra copy to allow to pack more the
718 * IrCOMM frames. This is advantageous because the IrDA link
719 * is the bottleneck. */
721 kbuf = kmalloc(count, GFP_KERNEL);
724 if (copy_from_user(kbuf, ubuf, count))
727 /* The buffer is already in kernel space */
728 kbuf = (unsigned char *) ubuf;
730 /* Protect our manipulation of self->tx_skb and related */
731 spin_lock_irqsave(&self->spinlock, flags);
733 /* Fetch current transmit buffer */
737 * Send out all the data we get, possibly as multiple fragmented
738 * frames, but this will only happen if the data is larger than the
739 * max data size. The normal case however is just the opposite, and
740 * this function may be called multiple times, and will then actually
741 * defragment the data and send it out as one packet as soon as
742 * possible, but at a safer point in time
747 /* Adjust data size to the max data size */
748 if (size > self->max_data_size)
749 size = self->max_data_size;
752 * Do we already have a buffer ready for transmit, or do
753 * we need to allocate a new frame
757 * Any room for more data at the end of the current
758 * transmit buffer? Cannot use skb_tailroom, since
759 * dev_alloc_skb gives us a larger skb than we
761 * Note : use tx_data_size, because max_data_size
762 * may have changed and we don't want to overwrite
765 if ((tailroom = (self->tx_data_size - skb->len)) > 0) {
766 /* Adjust data to tailroom */
771 * Current transmit frame is full, so break
772 * out, so we can send it as soon as possible
777 /* Prepare a full sized frame */
778 skb = dev_alloc_skb(self->max_data_size+
779 self->max_header_size);
781 spin_unlock_irqrestore(&self->spinlock, flags);
784 skb_reserve(skb, self->max_header_size);
786 /* Remember skb size because max_data_size may
787 * change later on - Jean II */
788 self->tx_data_size = self->max_data_size;
792 memcpy(skb_put(skb,size), kbuf + len, size);
798 spin_unlock_irqrestore(&self->spinlock, flags);
804 * Schedule a new thread which will transmit the frame as soon
805 * as possible, but at a safe point in time. We do this so the
806 * "user" can give us data multiple times, as PPP does (because of
807 * its 256 byte tx buffer). We will then defragment and send out
808 * all this data as one single packet.
810 schedule_work(&self->tqueue);
816 * Function ircomm_tty_write_room (tty)
818 * This routine returns the numbers of characters the tty driver will
819 * accept for queuing to be written. This number is subject to change as
820 * output buffers get emptied, or if the output flow control is acted.
822 static int ircomm_tty_write_room(struct tty_struct *tty)
824 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
828 ASSERT(self != NULL, return -1;);
829 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
831 #ifdef IRCOMM_NO_TX_BEFORE_INIT
832 /* max_header_size tells us if the channel is initialised or not. */
833 if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED)
834 /* Don't bother us yet */
838 /* Check if we are allowed to transmit any data.
839 * hw_stopped is the regular flow control.
844 spin_lock_irqsave(&self->spinlock, flags);
846 ret = self->tx_data_size - self->tx_skb->len;
848 ret = self->max_data_size;
849 spin_unlock_irqrestore(&self->spinlock, flags);
851 IRDA_DEBUG(2, "%s(), ret=%d\n", __FUNCTION__ , ret);
857 * Function ircomm_tty_wait_until_sent (tty, timeout)
859 * This routine waits until the device has written out all of the
860 * characters in its transmitter FIFO.
862 static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
864 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
865 unsigned long orig_jiffies, poll_time;
868 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
870 ASSERT(self != NULL, return;);
871 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
873 orig_jiffies = jiffies;
875 /* Set poll time to 200 ms */
876 poll_time = IRDA_MIN(timeout, MSECS_TO_JIFFIES(200));
878 spin_lock_irqsave(&self->spinlock, flags);
879 while (self->tx_skb && self->tx_skb->len) {
880 spin_unlock_irqrestore(&self->spinlock, flags);
881 current->state = TASK_INTERRUPTIBLE;
882 schedule_timeout(poll_time);
883 spin_lock_irqsave(&self->spinlock, flags);
884 if (signal_pending(current))
886 if (timeout && time_after(jiffies, orig_jiffies + timeout))
889 spin_unlock_irqrestore(&self->spinlock, flags);
890 current->state = TASK_RUNNING;
894 * Function ircomm_tty_throttle (tty)
896 * This routine notifies the tty driver that input buffers for the line
897 * discipline are close to full, and it should somehow signal that no
898 * more characters should be sent to the tty.
900 static void ircomm_tty_throttle(struct tty_struct *tty)
902 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
904 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
906 ASSERT(self != NULL, return;);
907 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
909 /* Software flow control? */
911 ircomm_tty_send_xchar(tty, STOP_CHAR(tty));
913 /* Hardware flow control? */
914 if (tty->termios->c_cflag & CRTSCTS) {
915 self->settings.dte &= ~IRCOMM_RTS;
916 self->settings.dte |= IRCOMM_DELTA_RTS;
918 ircomm_param_request(self, IRCOMM_DTE, TRUE);
921 ircomm_flow_request(self->ircomm, FLOW_STOP);
925 * Function ircomm_tty_unthrottle (tty)
927 * This routine notifies the tty drivers that it should signals that
928 * characters can now be sent to the tty without fear of overrunning the
929 * input buffers of the line disciplines.
931 static void ircomm_tty_unthrottle(struct tty_struct *tty)
933 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
935 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
937 ASSERT(self != NULL, return;);
938 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
940 /* Using software flow control? */
942 ircomm_tty_send_xchar(tty, START_CHAR(tty));
945 /* Using hardware flow control? */
946 if (tty->termios->c_cflag & CRTSCTS) {
947 self->settings.dte |= (IRCOMM_RTS|IRCOMM_DELTA_RTS);
949 ircomm_param_request(self, IRCOMM_DTE, TRUE);
950 IRDA_DEBUG(1, "%s(), FLOW_START\n", __FUNCTION__ );
952 ircomm_flow_request(self->ircomm, FLOW_START);
956 * Function ircomm_tty_chars_in_buffer (tty)
958 * Indicates if there are any data in the buffer
961 static int ircomm_tty_chars_in_buffer(struct tty_struct *tty)
963 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
967 ASSERT(self != NULL, return -1;);
968 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
970 spin_lock_irqsave(&self->spinlock, flags);
973 len = self->tx_skb->len;
975 spin_unlock_irqrestore(&self->spinlock, flags);
980 static void ircomm_tty_shutdown(struct ircomm_tty_cb *self)
984 ASSERT(self != NULL, return;);
985 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
987 IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
989 if (!test_and_clear_bit(ASYNC_B_INITIALIZED, &self->flags))
992 ircomm_tty_detach_cable(self);
994 spin_lock_irqsave(&self->spinlock, flags);
996 del_timer(&self->watchdog_timer);
998 /* Free parameter buffer */
999 if (self->ctrl_skb) {
1000 dev_kfree_skb(self->ctrl_skb);
1001 self->ctrl_skb = NULL;
1004 /* Free transmit buffer */
1006 dev_kfree_skb(self->tx_skb);
1007 self->tx_skb = NULL;
1011 ircomm_close(self->ircomm);
1012 self->ircomm = NULL;
1015 spin_unlock_irqrestore(&self->spinlock, flags);
1019 * Function ircomm_tty_hangup (tty)
1021 * This routine notifies the tty driver that it should hangup the tty
1025 static void ircomm_tty_hangup(struct tty_struct *tty)
1027 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
1028 unsigned long flags;
1030 IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
1032 ASSERT(self != NULL, return;);
1033 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
1038 /* ircomm_tty_flush_buffer(tty); */
1039 ircomm_tty_shutdown(self);
1041 /* I guess we need to lock here - Jean II */
1042 spin_lock_irqsave(&self->spinlock, flags);
1043 self->flags &= ~ASYNC_NORMAL_ACTIVE;
1045 self->open_count = 0;
1046 spin_unlock_irqrestore(&self->spinlock, flags);
1048 wake_up_interruptible(&self->open_wait);
1052 * Function ircomm_tty_send_xchar (tty, ch)
1054 * This routine is used to send a high-priority XON/XOFF character to
1057 static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch)
1059 IRDA_DEBUG(0, "%s(), not impl\n", __FUNCTION__ );
1063 * Function ircomm_tty_start (tty)
1065 * This routine notifies the tty driver that it resume sending
1066 * characters to the tty device.
1068 void ircomm_tty_start(struct tty_struct *tty)
1070 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
1072 ircomm_flow_request(self->ircomm, FLOW_START);
1076 * Function ircomm_tty_stop (tty)
1078 * This routine notifies the tty driver that it should stop outputting
1079 * characters to the tty device.
1081 void ircomm_tty_stop(struct tty_struct *tty)
1083 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
1085 ASSERT(self != NULL, return;);
1086 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
1088 ircomm_flow_request(self->ircomm, FLOW_STOP);
1092 * Function ircomm_check_modem_status (self)
1094 * Check for any changes in the DCE's line settings. This function should
1095 * be called whenever the dce parameter settings changes, to update the
1096 * flow control settings and other things
1098 void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self)
1100 struct tty_struct *tty;
1103 IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );
1105 ASSERT(self != NULL, return;);
1106 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
1110 status = self->settings.dce;
1112 if (status & IRCOMM_DCE_DELTA_ANY) {
1113 /*wake_up_interruptible(&self->delta_msr_wait);*/
1115 if ((self->flags & ASYNC_CHECK_CD) && (status & IRCOMM_DELTA_CD)) {
1117 "%s(), ircomm%d CD now %s...\n", __FUNCTION__ , self->line,
1118 (status & IRCOMM_CD) ? "on" : "off");
1120 if (status & IRCOMM_CD) {
1121 wake_up_interruptible(&self->open_wait);
1124 "%s(), Doing serial hangup..\n", __FUNCTION__ );
1128 /* Hangup will remote the tty, so better break out */
1132 if (self->flags & ASYNC_CTS_FLOW) {
1133 if (tty->hw_stopped) {
1134 if (status & IRCOMM_CTS) {
1136 "%s(), CTS tx start...\n", __FUNCTION__ );
1137 tty->hw_stopped = 0;
1139 /* Wake up processes blocked on open */
1140 wake_up_interruptible(&self->open_wait);
1142 schedule_work(&self->tqueue);
1146 if (!(status & IRCOMM_CTS)) {
1148 "%s(), CTS tx stop...\n", __FUNCTION__ );
1149 tty->hw_stopped = 1;
1156 * Function ircomm_tty_data_indication (instance, sap, skb)
1158 * Handle incoming data, and deliver it to the line discipline
1161 static int ircomm_tty_data_indication(void *instance, void *sap,
1162 struct sk_buff *skb)
1164 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
1166 IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );
1168 ASSERT(self != NULL, return -1;);
1169 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
1170 ASSERT(skb != NULL, return -1;);
1173 IRDA_DEBUG(0, "%s(), no tty!\n", __FUNCTION__ );
1178 * If we receive data when hardware is stopped then something is wrong.
1179 * We try to poll the peers line settings to check if we are up todate.
1180 * Devices like WinCE can do this, and since they don't send any
1181 * params, we can just as well declare the hardware for running.
1183 if (self->tty->hw_stopped && (self->flow == FLOW_START)) {
1184 IRDA_DEBUG(0, "%s(), polling for line settings!\n", __FUNCTION__ );
1185 ircomm_param_request(self, IRCOMM_POLL, TRUE);
1187 /* We can just as well declare the hardware for running */
1188 ircomm_tty_send_initial_parameters(self);
1189 ircomm_tty_link_established(self);
1193 * Just give it over to the line discipline. There is no need to
1194 * involve the flip buffers, since we are not running in an interrupt
1197 self->tty->ldisc.receive_buf(self->tty, skb->data, NULL, skb->len);
1199 /* No need to kfree_skb - see ircomm_ttp_data_indication() */
1205 * Function ircomm_tty_control_indication (instance, sap, skb)
1207 * Parse all incoming parameters (easy!)
1210 static int ircomm_tty_control_indication(void *instance, void *sap,
1211 struct sk_buff *skb)
1213 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
1216 IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );
1218 ASSERT(self != NULL, return -1;);
1219 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
1220 ASSERT(skb != NULL, return -1;);
1222 clen = skb->data[0];
1224 irda_param_extract_all(self, skb->data+1, IRDA_MIN(skb->len-1, clen),
1225 &ircomm_param_info);
1227 /* No need to kfree_skb - see ircomm_control_indication() */
1233 * Function ircomm_tty_flow_indication (instance, sap, cmd)
1235 * This function is called by IrTTP when it wants us to slow down the
1236 * transmission of data. We just mark the hardware as stopped, and wait
1237 * for IrTTP to notify us that things are OK again.
1239 static void ircomm_tty_flow_indication(void *instance, void *sap,
1242 struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
1243 struct tty_struct *tty;
1245 ASSERT(self != NULL, return;);
1246 ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
1252 IRDA_DEBUG(2, "%s(), hw start!\n", __FUNCTION__ );
1253 tty->hw_stopped = 0;
1255 /* ircomm_tty_do_softint will take care of the rest */
1256 schedule_work(&self->tqueue);
1258 default: /* If we get here, something is very wrong, better stop */
1260 IRDA_DEBUG(2, "%s(), hw stopped!\n", __FUNCTION__ );
1261 tty->hw_stopped = 1;
1267 static int ircomm_tty_line_info(struct ircomm_tty_cb *self, char *buf)
1271 ret += sprintf(buf+ret, "State: %s\n", ircomm_tty_state[self->state]);
1273 ret += sprintf(buf+ret, "Service type: ");
1274 if (self->service_type & IRCOMM_9_WIRE)
1275 ret += sprintf(buf+ret, "9_WIRE");
1276 else if (self->service_type & IRCOMM_3_WIRE)
1277 ret += sprintf(buf+ret, "3_WIRE");
1278 else if (self->service_type & IRCOMM_3_WIRE_RAW)
1279 ret += sprintf(buf+ret, "3_WIRE_RAW");
1281 ret += sprintf(buf+ret, "No common service type!\n");
1282 ret += sprintf(buf+ret, "\n");
1284 ret += sprintf(buf+ret, "Port name: %s\n", self->settings.port_name);
1286 ret += sprintf(buf+ret, "DTE status: ");
1287 if (self->settings.dte & IRCOMM_RTS)
1288 ret += sprintf(buf+ret, "RTS|");
1289 if (self->settings.dte & IRCOMM_DTR)
1290 ret += sprintf(buf+ret, "DTR|");
1291 if (self->settings.dte)
1292 ret--; /* remove the last | */
1293 ret += sprintf(buf+ret, "\n");
1295 ret += sprintf(buf+ret, "DCE status: ");
1296 if (self->settings.dce & IRCOMM_CTS)
1297 ret += sprintf(buf+ret, "CTS|");
1298 if (self->settings.dce & IRCOMM_DSR)
1299 ret += sprintf(buf+ret, "DSR|");
1300 if (self->settings.dce & IRCOMM_CD)
1301 ret += sprintf(buf+ret, "CD|");
1302 if (self->settings.dce & IRCOMM_RI)
1303 ret += sprintf(buf+ret, "RI|");
1304 if (self->settings.dce)
1305 ret--; /* remove the last | */
1306 ret += sprintf(buf+ret, "\n");
1308 ret += sprintf(buf+ret, "Configuration: ");
1309 if (!self->settings.null_modem)
1310 ret += sprintf(buf+ret, "DTE <-> DCE\n");
1312 ret += sprintf(buf+ret,
1313 "DTE <-> DTE (null modem emulation)\n");
1315 ret += sprintf(buf+ret, "Data rate: %d\n", self->settings.data_rate);
1317 ret += sprintf(buf+ret, "Flow control: ");
1318 if (self->settings.flow_control & IRCOMM_XON_XOFF_IN)
1319 ret += sprintf(buf+ret, "XON_XOFF_IN|");
1320 if (self->settings.flow_control & IRCOMM_XON_XOFF_OUT)
1321 ret += sprintf(buf+ret, "XON_XOFF_OUT|");
1322 if (self->settings.flow_control & IRCOMM_RTS_CTS_IN)
1323 ret += sprintf(buf+ret, "RTS_CTS_IN|");
1324 if (self->settings.flow_control & IRCOMM_RTS_CTS_OUT)
1325 ret += sprintf(buf+ret, "RTS_CTS_OUT|");
1326 if (self->settings.flow_control & IRCOMM_DSR_DTR_IN)
1327 ret += sprintf(buf+ret, "DSR_DTR_IN|");
1328 if (self->settings.flow_control & IRCOMM_DSR_DTR_OUT)
1329 ret += sprintf(buf+ret, "DSR_DTR_OUT|");
1330 if (self->settings.flow_control & IRCOMM_ENQ_ACK_IN)
1331 ret += sprintf(buf+ret, "ENQ_ACK_IN|");
1332 if (self->settings.flow_control & IRCOMM_ENQ_ACK_OUT)
1333 ret += sprintf(buf+ret, "ENQ_ACK_OUT|");
1334 if (self->settings.flow_control)
1335 ret--; /* remove the last | */
1336 ret += sprintf(buf+ret, "\n");
1338 ret += sprintf(buf+ret, "Flags: ");
1339 if (self->flags & ASYNC_CTS_FLOW)
1340 ret += sprintf(buf+ret, "ASYNC_CTS_FLOW|");
1341 if (self->flags & ASYNC_CHECK_CD)
1342 ret += sprintf(buf+ret, "ASYNC_CHECK_CD|");
1343 if (self->flags & ASYNC_INITIALIZED)
1344 ret += sprintf(buf+ret, "ASYNC_INITIALIZED|");
1345 if (self->flags & ASYNC_LOW_LATENCY)
1346 ret += sprintf(buf+ret, "ASYNC_LOW_LATENCY|");
1347 if (self->flags & ASYNC_CLOSING)
1348 ret += sprintf(buf+ret, "ASYNC_CLOSING|");
1349 if (self->flags & ASYNC_NORMAL_ACTIVE)
1350 ret += sprintf(buf+ret, "ASYNC_NORMAL_ACTIVE|");
1352 ret--; /* remove the last | */
1353 ret += sprintf(buf+ret, "\n");
1355 ret += sprintf(buf+ret, "Role: %s\n", self->client ?
1356 "client" : "server");
1357 ret += sprintf(buf+ret, "Open count: %d\n", self->open_count);
1358 ret += sprintf(buf+ret, "Max data size: %d\n", self->max_data_size);
1359 ret += sprintf(buf+ret, "Max header size: %d\n", self->max_header_size);
1362 ret += sprintf(buf+ret, "Hardware: %s\n",
1363 self->tty->hw_stopped ? "Stopped" : "Running");
1365 ret += sprintf(buf+ret, "\n");
1371 * Function ircomm_tty_read_proc (buf, start, offset, len, eof, unused)
1376 #ifdef CONFIG_PROC_FS
1377 static int ircomm_tty_read_proc(char *buf, char **start, off_t offset, int len,
1378 int *eof, void *unused)
1380 struct ircomm_tty_cb *self;
1383 unsigned long flags;
1385 spin_lock_irqsave(&ircomm_tty->hb_spinlock, flags);
1387 self = (struct ircomm_tty_cb *) hashbin_get_first(ircomm_tty);
1388 while ((self != NULL) && (count < 4000)) {
1389 if (self->magic != IRCOMM_TTY_MAGIC)
1392 l = ircomm_tty_line_info(self, buf + count);
1394 if (count+begin > offset+len)
1396 if (count+begin < offset) {
1401 self = (struct ircomm_tty_cb *) hashbin_get_next(ircomm_tty);
1405 spin_unlock_irqrestore(&ircomm_tty->hb_spinlock, flags);
1407 if (offset >= count+begin)
1409 *start = buf + (offset-begin);
1410 return ((len < begin+count-offset) ? len : begin+count-offset);
1412 #endif /* CONFIG_PROC_FS */
1414 MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
1415 MODULE_DESCRIPTION("IrCOMM serial TTY driver");
1416 MODULE_LICENSE("GPL");
1417 MODULE_ALIAS_CHARDEV_MAJOR(IRCOMM_TTY_MAJOR);
1419 module_init(ircomm_tty_init);
1420 module_exit(ircomm_tty_cleanup);