/********************************************************************* *                 * Filename:      ircomm_tty.c * Version:       1.0 * Description:   IrCOMM serial TTY driver * Status:        Experimental. * Author:        Dag Brattli <dagb@cs.uit.no> * Created at:    Sun Jun  6 21:00:56 1999 * Modified at:   Wed Feb 23 00:09:02 2000 * Modified by:   Dag Brattli <dagb@cs.uit.no> * Sources:       serial.c and previous IrCOMM work by Takahide Higuchi *  *     Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved. *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com> *      *     This program is free software; you can redistribute it and/or  *     modify it under the terms of the GNU General Public License as  *     published by the Free Software Foundation; either version 2 of  *     the License, or (at your option) any later version. *  *     This program is distributed in the hope that it will be useful, *     but WITHOUT ANY WARRANTY; without even the implied warranty of *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *     GNU General Public License for more details. *  *     You should have received a copy of the GNU General Public License  *     along with this program; if not, write to the Free Software  *     Foundation, Inc., 59 Temple Place, Suite 330, Boston,  *     MA 02111-1307 USA *      ********************************************************************/#include <linux/config.h>#include <linux/init.h>#include <linux/module.h>#include <linux/fs.h>#include <linux/sched.h>#include <linux/termios.h>#include <linux/tty.h>#include <linux/interrupt.h>#include <linux/device.h>		/* for MODULE_ALIAS_CHARDEV_MAJOR */#include <asm/uaccess.h>#include <net/irda/irda.h>#include <net/irda/irmod.h>#include <net/irda/ircomm_core.h>#include <net/irda/ircomm_param.h>#include <net/irda/ircomm_tty_attach.h>#include <net/irda/ircomm_tty.h>static int  ircomm_tty_open(struct tty_struct *tty, struct file *filp);static void ircomm_tty_close(struct tty_struct * tty, struct file *filp);static int  ircomm_tty_write(struct tty_struct * tty, int from_user,			     const unsigned char *buf, int count);static int  ircomm_tty_write_room(struct tty_struct *tty);static void ircomm_tty_throttle(struct tty_struct *tty);static void ircomm_tty_unthrottle(struct tty_struct *tty);static int  ircomm_tty_chars_in_buffer(struct tty_struct *tty);static void ircomm_tty_flush_buffer(struct tty_struct *tty);static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch);static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout);static void ircomm_tty_hangup(struct tty_struct *tty);static void ircomm_tty_do_softint(void *private_);static void ircomm_tty_shutdown(struct ircomm_tty_cb *self);static int ircomm_tty_data_indication(void *instance, void *sap,				      struct sk_buff *skb);static int ircomm_tty_control_indication(void *instance, void *sap,					 struct sk_buff *skb);static void ircomm_tty_flow_indication(void *instance, void *sap, 				       LOCAL_FLOW cmd);#ifdef CONFIG_PROC_FSstatic int ircomm_tty_read_proc(char *buf, char **start, off_t offset, int len,				int *eof, void *unused);#endif /* CONFIG_PROC_FS */static struct tty_driver *driver;hashbin_t *ircomm_tty = NULL;static struct tty_operations ops = {	.open            = ircomm_tty_open,	.close           = ircomm_tty_close,	.write           = ircomm_tty_write,	.write_room      = ircomm_tty_write_room,	.chars_in_buffer = ircomm_tty_chars_in_buffer,	.flush_buffer    = ircomm_tty_flush_buffer,	.ioctl           = ircomm_tty_ioctl,	/* ircomm_tty_ioctl.c */	.tiocmget        = ircomm_tty_tiocmget,	/* ircomm_tty_ioctl.c */	.tiocmset        = ircomm_tty_tiocmset,	/* ircomm_tty_ioctl.c */	.throttle        = ircomm_tty_throttle,	.unthrottle      = ircomm_tty_unthrottle,	.send_xchar      = ircomm_tty_send_xchar,	.set_termios     = ircomm_tty_set_termios,	.stop            = ircomm_tty_stop,	.start           = ircomm_tty_start,	.hangup          = ircomm_tty_hangup,	.wait_until_sent = ircomm_tty_wait_until_sent,#ifdef CONFIG_PROC_FS	.read_proc       = ircomm_tty_read_proc,#endif /* CONFIG_PROC_FS */};/* * Function ircomm_tty_init() * *    Init IrCOMM TTY layer/driver * */int __init ircomm_tty_init(void){	driver = alloc_tty_driver(IRCOMM_TTY_PORTS);	if (!driver)		return -ENOMEM;	ircomm_tty = hashbin_new(HB_LOCK); 	if (ircomm_tty == NULL) {		ERROR("%s(), can't allocate hashbin!\n", __FUNCTION__);		put_tty_driver(driver);		return -ENOMEM;	}	driver->owner		= THIS_MODULE;	driver->driver_name     = "ircomm";	driver->name            = "ircomm";	driver->devfs_name      = "ircomm";	driver->major           = IRCOMM_TTY_MAJOR;	driver->minor_start     = IRCOMM_TTY_MINOR;	driver->type            = TTY_DRIVER_TYPE_SERIAL;	driver->subtype         = SERIAL_TYPE_NORMAL;	driver->init_termios    = tty_std_termios;	driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;	driver->flags           = TTY_DRIVER_REAL_RAW;	tty_set_operations(driver, &ops);	if (tty_register_driver(driver)) {		ERROR("%s(): Couldn't register serial driver\n", __FUNCTION__);		put_tty_driver(driver);		return -1;	}	return 0;}static void __exit __ircomm_tty_cleanup(struct ircomm_tty_cb *self){	IRDA_DEBUG(0, "%s()\n", __FUNCTION__ );	ASSERT(self != NULL, return;);	ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);	ircomm_tty_shutdown(self);	self->magic = 0;	kfree(self);}/* * Function ircomm_tty_cleanup () * *    Remove IrCOMM TTY layer/driver * */void __exit ircomm_tty_cleanup(void){	int ret;	IRDA_DEBUG(4, "%s()\n", __FUNCTION__ );		ret = tty_unregister_driver(driver);        if (ret) {                ERROR("%s(), failed to unregister driver\n", __FUNCTION__);		return;	}	hashbin_delete(ircomm_tty, (FREE_FUNC) __ircomm_tty_cleanup);	put_tty_driver(driver);}/* * Function ircomm_startup (self) * *     * */static int ircomm_tty_startup(struct ircomm_tty_cb *self){	notify_t notify;	int ret = -ENODEV;	IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );	ASSERT(self != NULL, return -1;);	ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);	/* Check if already open */	if (test_and_set_bit(ASYNC_B_INITIALIZED, &self->flags)) {		IRDA_DEBUG(2, "%s(), already open so break out!\n", __FUNCTION__ );		return 0;	}	/* Register with IrCOMM */	irda_notify_init(&notify);	/* These callbacks we must handle ourselves */	notify.data_indication       = ircomm_tty_data_indication;	notify.udata_indication      = ircomm_tty_control_indication; 	notify.flow_indication       = ircomm_tty_flow_indication;	/* Use the ircomm_tty interface for these ones */ 	notify.disconnect_indication = ircomm_tty_disconnect_indication;	notify.connect_confirm       = ircomm_tty_connect_confirm; 	notify.connect_indication    = ircomm_tty_connect_indication;	strlcpy(notify.name, "ircomm_tty", sizeof(notify.name));	notify.instance = self;	if (!self->ircomm) {		self->ircomm = ircomm_open(&notify, self->service_type, 					   self->line);	}	if (!self->ircomm)		goto err;	self->slsap_sel = self->ircomm->slsap_sel;	/* Connect IrCOMM link with remote device */	ret = ircomm_tty_attach_cable(self);	if (ret < 0) {		ERROR("%s(), error attaching cable!\n", __FUNCTION__);		goto err;	}	return 0;err:	clear_bit(ASYNC_B_INITIALIZED, &self->flags);	return ret;}/* * Function ircomm_block_til_ready (self, filp) * *     * */static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self, 				      struct file *filp){	DECLARE_WAITQUEUE(wait, current);	int		retval;	int		do_clocal = 0, extra_count = 0;	unsigned long	flags;	struct tty_struct *tty;		IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );	tty = self->tty;	/*	 * If non-blocking mode is set, or the port is not enabled,	 * then make the check up front and then exit.	 */		if (filp->f_flags & O_NONBLOCK || tty->flags & (1 << TTY_IO_ERROR)){		/* nonblock mode is set or port is not enabled */		self->flags |= ASYNC_NORMAL_ACTIVE;		IRDA_DEBUG(1, "%s(), O_NONBLOCK requested!\n", __FUNCTION__ );		return 0;	}	if (tty->termios->c_cflag & CLOCAL) {		IRDA_DEBUG(1, "%s(), doing CLOCAL!\n", __FUNCTION__ );		do_clocal = 1;	}		/* Wait for carrier detect and the line to become	 * free (i.e., not in use by the callout).  While we are in	 * this loop, self->open_count is dropped by one, so that	 * mgsl_close() knows when to free things.  We restore it upon	 * exit, either normal or abnormal.	 */	 	retval = 0;	add_wait_queue(&self->open_wait, &wait);		IRDA_DEBUG(2, "%s(%d):block_til_ready before block on %s open_count=%d\n",	      __FILE__,__LINE__, tty->driver->name, self->open_count );	/* As far as I can see, we protect open_count - Jean II */	spin_lock_irqsave(&self->spinlock, flags);	if (!tty_hung_up_p(filp)) {		extra_count = 1;		self->open_count--;	}	spin_unlock_irqrestore(&self->spinlock, flags);	self->blocked_open++;		while (1) {		if (tty->termios->c_cflag & CBAUD) {			/* Here, we use to lock those two guys, but			 * as ircomm_param_request() does it itself,			 * I don't see the point (and I see the deadlock).			 * Jean II */			self->settings.dte |= IRCOMM_RTS + IRCOMM_DTR;		 				ircomm_param_request(self, IRCOMM_DTE, TRUE);		}				current->state = TASK_INTERRUPTIBLE;				if (tty_hung_up_p(filp) ||		    !test_bit(ASYNC_B_INITIALIZED, &self->flags)) {			retval = (self->flags & ASYNC_HUP_NOTIFY) ?					-EAGAIN : -ERESTARTSYS;			break;		}				/*  		 * Check if link is ready now. Even if CLOCAL is		 * specified, we cannot return before the IrCOMM link is		 * ready 		 */ 		if (!test_bit(ASYNC_B_CLOSING, &self->flags) && 		    (do_clocal || (self->settings.dce & IRCOMM_CD)) &&		    self->state == IRCOMM_TTY_READY)		{ 			break;		}					if (signal_pending(current)) {			retval = -ERESTARTSYS;			break;		}				IRDA_DEBUG(1, "%s(%d):block_til_ready blocking on %s open_count=%d\n",		      __FILE__,__LINE__, tty->driver->name, self->open_count );				schedule();	}		__set_current_state(TASK_RUNNING);	remove_wait_queue(&self->open_wait, &wait);		if (extra_count) {		/* ++ is not atomic, so this should be protected - Jean II */		spin_lock_irqsave(&self->spinlock, flags);		self->open_count++;		spin_unlock_irqrestore(&self->spinlock, flags);	}	self->blocked_open--;		IRDA_DEBUG(1, "%s(%d):block_til_ready after blocking on %s open_count=%d\n",	      __FILE__,__LINE__, tty->driver->name, self->open_count);			 	if (!retval)		self->flags |= ASYNC_NORMAL_ACTIVE;			return retval;	}/* * Function ircomm_tty_open (tty, filp) * *    This routine is called when a particular tty device is opened. This *    routine is mandatory; if this routine is not filled in, the attempted *    open will fail with ENODEV. */static int ircomm_tty_open(struct tty_struct *tty, struct file *filp){	struct ircomm_tty_cb *self;	unsigned int line;	unsigned long	flags;	int ret;	IRDA_DEBUG(2, "%s()\n", __FUNCTION__ );	line = tty->index;	if ((line < 0) || (line >= IRCOMM_TTY_PORTS)) {		return -ENODEV;	}	/* Check if instance already exists */	self = hashbin_lock_find(ircomm_tty, line, NULL);	if (!self) {		/* No, so make new instance */		self = kmalloc(sizeof(struct ircomm_tty_cb), GFP_KERNEL);		if (self == NULL) {			ERROR("%s(), kmalloc failed!\n", __FUNCTION__);			return -ENOMEM;		}		memset(self, 0, sizeof(struct ircomm_tty_cb));				self->magic = IRCOMM_TTY_MAGIC;		self->flow = FLOW_STOP;		self->line = line;		INIT_WORK(&self->tqueue, ircomm_tty_do_softint, self);		self->max_header_size = IRCOMM_TTY_HDR_UNINITIALISED;		self->max_data_size = IRCOMM_TTY_DATA_UNINITIALISED;		self->close_delay = 5*HZ/10;		self->closing_wait = 30*HZ;		/* Init some important stuff */		init_timer(&self->watchdog_timer);		init_waitqueue_head(&self->open_wait); 		init_waitqueue_head(&self->close_wait);		spin_lock_init(&self->spinlock);		/* 		 * Force TTY into raw mode by default which is usually what		 * we want for IrCOMM and IrLPT. This way applications will		 * not have to twiddle with printcap etc.  		 */		tty->termios->c_iflag = 0;		tty->termios->c_oflag = 0;		/* Insert into hash */		hashbin_insert(ircomm_tty, (irda_queue_t *) self, line, NULL);	}	/* ++ is not atomic, so this should be protected - Jean II */	spin_lock_irqsave(&self->spinlock, flags);	self->open_count++;	tty->driver_data = self;	self->tty = tty;	spin_unlock_irqrestore(&self->spinlock, flags);	IRDA_DEBUG(1, "%s(), %s%d, count = %d\n", __FUNCTION__ , tty->driver->name, 		   self->line, self->open_count);	/* Not really used by us, but lets do it anyway */	self->tty->low_latency = (self->flags & ASYNC_LOW_LATENCY) ? 1 : 0;	/*	 * If the port is the middle of closing, bail out now	 */	if (tty_hung_up_p(filp) ||	    test_bit(ASYNC_B_CLOSING, &self->flags)) {		/* Hm, why are we blocking on ASYNC_CLOSING if we		 * do return -EAGAIN/-ERESTARTSYS below anyway?		 * IMHO it's either not needed in the first place		 * or for some reason we need to make sure the async		 * closing has been finished - if so, wouldn't we		 * probably better sleep uninterruptible?		 */		if (wait_event_interruptible(self->close_wait, !test_bit(ASYNC_B_CLOSING, &self->flags))) {			WARNING("%s - got signal while blocking on ASYNC_CLOSING!\n",				__FUNCTION__);			return -ERESTARTSYS;		}#ifdef SERIAL_DO_RESTART		return ((self->flags & ASYNC_HUP_NOTIFY) ?			-EAGAIN : -ERESTARTSYS);#else		return -EAGAIN;#endif	}	/* Check if this is a "normal" ircomm device, or an irlpt device */	if (line < 0x10) {		self->service_type = IRCOMM_3_WIRE | IRCOMM_9_WIRE;		self->settings.service_type = IRCOMM_9_WIRE; /* 9 wire as default */		/* Jan Kiszka -> add DSR/RI -> Conform to IrCOMM spec */		self->settings.dce = IRCOMM_CTS | IRCOMM_CD | IRCOMM_DSR | IRCOMM_RI; /* Default line settings */		IRDA_DEBUG(2, "%s(), IrCOMM device\n", __FUNCTION__ );	} else {		IRDA_DEBUG(2, "%s(), IrLPT device\n", __FUNCTION__ );		self->service_type = IRCOMM_3_WIRE_RAW;		self->settings.service_type = IRCOMM_3_WIRE_RAW; /* Default */	}	ret = ircomm_tty_startup(self);	if (ret)		return ret;	ret = ircomm_tty_block_til_ready(self, filp);	if (ret) {