[mirror_ubuntu-artful-kernel.git] / net / irda / ircomm / ircomm_tty_ioctl.c

/*********************************************************************
 *
 * Filename:      ircomm_tty_ioctl.c
 * Version:
 * Description:
 * Status:        Experimental.
 * Author:        Dag Brattli <dagb@cs.uit.no>
 * Created at:    Thu Jun 10 14:39:09 1999
 * Modified at:   Wed Jan  5 14:45:43 2000
 * Modified by:   Dag Brattli <dagb@cs.uit.no>
 *
 *     Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
 *
 *     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/init.h>
#include <linux/fs.h>
#include <linux/termios.h>
#include <linux/tty.h>
#include <linux/serial.h>

#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>

#define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))

/*
 * Function ircomm_tty_change_speed (driver)
 *
 *    Change speed of the driver. If the remote device is a DCE, then this
 *    should make it change the speed of its serial port
 */
static void ircomm_tty_change_speed(struct ircomm_tty_cb *self)
{
	unsigned cflag, cval;
	int baud;

	IRDA_DEBUG(2, "%s()\n", __func__ );

	if (!self->tty || !self->tty->termios || !self->ircomm)
		return;

	cflag = self->tty->termios->c_cflag;

	/*  byte size and parity */
	switch (cflag & CSIZE) {
	case CS5: cval = IRCOMM_WSIZE_5; break;
	case CS6: cval = IRCOMM_WSIZE_6; break;
	case CS7: cval = IRCOMM_WSIZE_7; break;
	case CS8: cval = IRCOMM_WSIZE_8; break;
	default:  cval = IRCOMM_WSIZE_5; break;
	}
	if (cflag & CSTOPB)
		cval |= IRCOMM_2_STOP_BIT;

	if (cflag & PARENB)
		cval |= IRCOMM_PARITY_ENABLE;
	if (!(cflag & PARODD))
		cval |= IRCOMM_PARITY_EVEN;

	/* Determine divisor based on baud rate */
	baud = tty_get_baud_rate(self->tty);
	if (!baud)
		baud = 9600;	/* B0 transition handled in rs_set_termios */

	self->settings.data_rate = baud;
	ircomm_param_request(self, IRCOMM_DATA_RATE, FALSE);

	/* CTS flow control flag and modem status interrupts */
	if (cflag & CRTSCTS) {
		self->flags |= ASYNC_CTS_FLOW;
		self->settings.flow_control |= IRCOMM_RTS_CTS_IN;
		/* This got me. Bummer. Jean II */
		if (self->service_type == IRCOMM_3_WIRE_RAW)
			IRDA_WARNING("%s(), enabling RTS/CTS on link that doesn't support it (3-wire-raw)\n", __func__);
	} else {
		self->flags &= ~ASYNC_CTS_FLOW;
		self->settings.flow_control &= ~IRCOMM_RTS_CTS_IN;
	}
	if (cflag & CLOCAL)
		self->flags &= ~ASYNC_CHECK_CD;
	else
		self->flags |= ASYNC_CHECK_CD;
#if 0
	/*
	 * Set up parity check flag
	 */

	if (I_INPCK(self->tty))
		driver->read_status_mask |= LSR_FE | LSR_PE;
	if (I_BRKINT(driver->tty) || I_PARMRK(driver->tty))
		driver->read_status_mask |= LSR_BI;

	/*
	 * Characters to ignore
	 */
	driver->ignore_status_mask = 0;
	if (I_IGNPAR(driver->tty))
		driver->ignore_status_mask |= LSR_PE | LSR_FE;

	if (I_IGNBRK(self->tty)) {
		self->ignore_status_mask |= LSR_BI;
		/*
		 * If we're ignore parity and break indicators, ignore
		 * overruns too. (For real raw support).
		 */
		if (I_IGNPAR(self->tty))
			self->ignore_status_mask |= LSR_OE;
	}
#endif
	self->settings.data_format = cval;

	ircomm_param_request(self, IRCOMM_DATA_FORMAT, FALSE);
	ircomm_param_request(self, IRCOMM_FLOW_CONTROL, TRUE);
}

/*
 * Function ircomm_tty_set_termios (tty, old_termios)
 *
 *    This routine allows the tty driver to be notified when device's
 *    termios settings have changed.  Note that a well-designed tty driver
 *    should be prepared to accept the case where old == NULL, and try to
 *    do something rational.
 */
void ircomm_tty_set_termios(struct tty_struct *tty,
			    struct ktermios *old_termios)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
	unsigned int cflag = tty->termios->c_cflag;

	IRDA_DEBUG(2, "%s()\n", __func__ );

	if ((cflag == old_termios->c_cflag) &&
	    (RELEVANT_IFLAG(tty->termios->c_iflag) ==
	     RELEVANT_IFLAG(old_termios->c_iflag)))
	{
		return;
	}

	ircomm_tty_change_speed(self);

	/* Handle transition to B0 status */
	if ((old_termios->c_cflag & CBAUD) &&
	    !(cflag & CBAUD)) {
		self->settings.dte &= ~(IRCOMM_DTR|IRCOMM_RTS);
		ircomm_param_request(self, IRCOMM_DTE, TRUE);
	}

	/* Handle transition away from B0 status */
	if (!(old_termios->c_cflag & CBAUD) &&
	    (cflag & CBAUD)) {
		self->settings.dte |= IRCOMM_DTR;
		if (!(tty->termios->c_cflag & CRTSCTS) ||
		    !test_bit(TTY_THROTTLED, &tty->flags)) {
			self->settings.dte |= IRCOMM_RTS;
		}
		ircomm_param_request(self, IRCOMM_DTE, TRUE);
	}

	/* Handle turning off CRTSCTS */
	if ((old_termios->c_cflag & CRTSCTS) &&
	    !(tty->termios->c_cflag & CRTSCTS))
	{
		tty->hw_stopped = 0;
		ircomm_tty_start(tty);
	}
}

/*
 * Function ircomm_tty_tiocmget (tty, file)
 *
 *
 *
 */
int ircomm_tty_tiocmget(struct tty_struct *tty, struct file *file)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
	unsigned int result;

	IRDA_DEBUG(2, "%s()\n", __func__ );

	if (tty->flags & (1 << TTY_IO_ERROR))
		return -EIO;

	result =  ((self->settings.dte & IRCOMM_RTS) ? TIOCM_RTS : 0)
		| ((self->settings.dte & IRCOMM_DTR) ? TIOCM_DTR : 0)
		| ((self->settings.dce & IRCOMM_CD)  ? TIOCM_CAR : 0)
		| ((self->settings.dce & IRCOMM_RI)  ? TIOCM_RNG : 0)
		| ((self->settings.dce & IRCOMM_DSR) ? TIOCM_DSR : 0)
		| ((self->settings.dce & IRCOMM_CTS) ? TIOCM_CTS : 0);
	return result;
}

/*
 * Function ircomm_tty_tiocmset (tty, file, set, clear)
 *
 *
 *
 */
int ircomm_tty_tiocmset(struct tty_struct *tty, struct file *file,
			unsigned int set, unsigned int clear)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;

	IRDA_DEBUG(2, "%s()\n", __func__ );

	if (tty->flags & (1 << TTY_IO_ERROR))
		return -EIO;

	IRDA_ASSERT(self != NULL, return -1;);
	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);

	if (set & TIOCM_RTS)
		self->settings.dte |= IRCOMM_RTS;
	if (set & TIOCM_DTR)
		self->settings.dte |= IRCOMM_DTR;

	if (clear & TIOCM_RTS)
		self->settings.dte &= ~IRCOMM_RTS;
	if (clear & TIOCM_DTR)
		self->settings.dte &= ~IRCOMM_DTR;

	if ((set|clear) & TIOCM_RTS)
		self->settings.dte |= IRCOMM_DELTA_RTS;
	if ((set|clear) & TIOCM_DTR)
		self->settings.dte |= IRCOMM_DELTA_DTR;

	ircomm_param_request(self, IRCOMM_DTE, TRUE);

	return 0;
}

/*
 * Function get_serial_info (driver, retinfo)
 *
 *
 *
 */
static int ircomm_tty_get_serial_info(struct ircomm_tty_cb *self,
				      struct serial_struct __user *retinfo)
{
	struct serial_struct info;

	if (!retinfo)
		return -EFAULT;

	IRDA_DEBUG(2, "%s()\n", __func__ );

	memset(&info, 0, sizeof(info));
	info.line = self->line;
	info.flags = self->flags;
	info.baud_base = self->settings.data_rate;
	info.close_delay = self->close_delay;
	info.closing_wait = self->closing_wait;

	/* For compatibility  */
	info.type = PORT_16550A;
	info.port = 0;
	info.irq = 0;
	info.xmit_fifo_size = 0;
	info.hub6 = 0;
	info.custom_divisor = 0;

	if (copy_to_user(retinfo, &info, sizeof(*retinfo)))
		return -EFAULT;

	return 0;
}

/*
 * Function set_serial_info (driver, new_info)
 *
 *
 *
 */
static int ircomm_tty_set_serial_info(struct ircomm_tty_cb *self,
				      struct serial_struct __user *new_info)
{
#if 0
	struct serial_struct new_serial;
	struct ircomm_tty_cb old_state, *state;

	IRDA_DEBUG(0, "%s()\n", __func__ );

	if (copy_from_user(&new_serial,new_info,sizeof(new_serial)))
		return -EFAULT;


	state = self
	old_state = *self;

	if (!capable(CAP_SYS_ADMIN)) {
		if ((new_serial.baud_base != state->settings.data_rate) ||
		    (new_serial.close_delay != state->close_delay) ||
		    ((new_serial.flags & ~ASYNC_USR_MASK) !=
		     (self->flags & ~ASYNC_USR_MASK)))
			return -EPERM;
		state->flags = ((state->flags & ~ASYNC_USR_MASK) |
				 (new_serial.flags & ASYNC_USR_MASK));
		self->flags = ((self->flags & ~ASYNC_USR_MASK) |
			       (new_serial.flags & ASYNC_USR_MASK));
		/* self->custom_divisor = new_serial.custom_divisor; */
		goto check_and_exit;
	}

	/*
	 * OK, past this point, all the error checking has been done.
	 * At this point, we start making changes.....
	 */

	if (self->settings.data_rate != new_serial.baud_base) {
		self->settings.data_rate = new_serial.baud_base;
		ircomm_param_request(self, IRCOMM_DATA_RATE, TRUE);
	}

	self->close_delay = new_serial.close_delay * HZ/100;
	self->closing_wait = new_serial.closing_wait * HZ/100;
	/* self->custom_divisor = new_serial.custom_divisor; */

	self->flags = ((self->flags & ~ASYNC_FLAGS) |
		       (new_serial.flags & ASYNC_FLAGS));
	self->tty->low_latency = (self->flags & ASYNC_LOW_LATENCY) ? 1 : 0;

 check_and_exit:

	if (self->flags & ASYNC_INITIALIZED) {
		if (((old_state.flags & ASYNC_SPD_MASK) !=
		     (self->flags & ASYNC_SPD_MASK)) ||
		    (old_driver.custom_divisor != driver->custom_divisor)) {
			if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
				driver->tty->alt_speed = 57600;
			if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
				driver->tty->alt_speed = 115200;
			if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
				driver->tty->alt_speed = 230400;
			if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
				driver->tty->alt_speed = 460800;
			ircomm_tty_change_speed(driver);
		}
	}
#endif
	return 0;
}

/*
 * Function ircomm_tty_ioctl (tty, file, cmd, arg)
 *
 *
 *
 */
int ircomm_tty_ioctl(struct tty_struct *tty, struct file *file,
		     unsigned int cmd, unsigned long arg)
{
	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
	int ret = 0;

	IRDA_DEBUG(2, "%s()\n", __func__ );

	if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
	    (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) &&
	    (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
		if (tty->flags & (1 << TTY_IO_ERROR))
		    return -EIO;
	}

	switch (cmd) {
	case TIOCGSERIAL:
		ret = ircomm_tty_get_serial_info(self, (struct serial_struct __user *) arg);
		break;
	case TIOCSSERIAL:
		ret = ircomm_tty_set_serial_info(self, (struct serial_struct __user *) arg);
		break;
	case TIOCMIWAIT:
		IRDA_DEBUG(0, "(), TIOCMIWAIT, not impl!\n");
		break;

	case TIOCGICOUNT:
		IRDA_DEBUG(0, "%s(), TIOCGICOUNT not impl!\n", __func__ );
#if 0
		save_flags(flags); cli();
		cnow = driver->icount;
		restore_flags(flags);
		p_cuser = (struct serial_icounter_struct __user *) arg;
		if (put_user(cnow.cts, &p_cuser->cts) ||
		    put_user(cnow.dsr, &p_cuser->dsr) ||
		    put_user(cnow.rng, &p_cuser->rng) ||
		    put_user(cnow.dcd, &p_cuser->dcd) ||
		    put_user(cnow.rx, &p_cuser->rx) ||
		    put_user(cnow.tx, &p_cuser->tx) ||
		    put_user(cnow.frame, &p_cuser->frame) ||
		    put_user(cnow.overrun, &p_cuser->overrun) ||
		    put_user(cnow.parity, &p_cuser->parity) ||
		    put_user(cnow.brk, &p_cuser->brk) ||
		    put_user(cnow.buf_overrun, &p_cuser->buf_overrun))
			return -EFAULT;
#endif
		return 0;
	default:
		ret = -ENOIOCTLCMD;  /* ioctls which we must ignore */
	}
	return ret;
}
Commit	Line	Data
1da177e4	1	/*********************************************************************
6819bc2e	2	*
1da177e4	3	* Filename: ircomm_tty_ioctl.c
6819bc2e YH	4	* Version:
6819bc2e YH	5	* Description:
1da177e4 LT	6	* Status: Experimental.
	7	* Author: Dag Brattli <dagb@cs.uit.no>
	8	* Created at: Thu Jun 10 14:39:09 1999
	9	* Modified at: Wed Jan 5 14:45:43 2000
	10	* Modified by: Dag Brattli <dagb@cs.uit.no>
6819bc2e	11	*
1da177e4	12	* Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
6819bc2e YH	13	*
	14	* This program is free software; you can redistribute it and/or
	15	* modify it under the terms of the GNU General Public License as
	16	* published by the Free Software Foundation; either version 2 of
1da177e4	17	* the License, or (at your option) any later version.
6819bc2e	18	*
1da177e4 LT	19	* This program is distributed in the hope that it will be useful,
	20	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	21	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	22	* GNU General Public License for more details.
6819bc2e YH	23	*
	24	* You should have received a copy of the GNU General Public License
	25	* along with this program; if not, write to the Free Software
	26	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
1da177e4	27	* MA 02111-1307 USA
6819bc2e	28	*
1da177e4 LT	29	********************************************************************/
	30
	31	#include <linux/init.h>
	32	#include <linux/fs.h>
1da177e4 LT	33	#include <linux/termios.h>
	34	#include <linux/tty.h>
	35	#include <linux/serial.h>
	36
	37	#include <asm/uaccess.h>
	38
	39	#include <net/irda/irda.h>
	40	#include <net/irda/irmod.h>
	41
	42	#include <net/irda/ircomm_core.h>
	43	#include <net/irda/ircomm_param.h>
	44	#include <net/irda/ircomm_tty_attach.h>
	45	#include <net/irda/ircomm_tty.h>
	46
	47	#define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK\|BRKINT\|IGNPAR\|PARMRK\|INPCK))
	48
	49	/*
	50	* Function ircomm_tty_change_speed (driver)
	51	*
	52	* Change speed of the driver. If the remote device is a DCE, then this
	53	* should make it change the speed of its serial port
	54	*/
	55	static void ircomm_tty_change_speed(struct ircomm_tty_cb *self)
	56	{
	57	unsigned cflag, cval;
	58	int baud;
	59
0dc47877	60	IRDA_DEBUG(2, "%s()\n", __func__ );
1da177e4 LT	61
	62	if (!self->tty \|\| !self->tty->termios \|\| !self->ircomm)
	63	return;
	64
	65	cflag = self->tty->termios->c_cflag;
	66
	67	/* byte size and parity */
	68	switch (cflag & CSIZE) {
	69	case CS5: cval = IRCOMM_WSIZE_5; break;
	70	case CS6: cval = IRCOMM_WSIZE_6; break;
	71	case CS7: cval = IRCOMM_WSIZE_7; break;
	72	case CS8: cval = IRCOMM_WSIZE_8; break;
	73	default: cval = IRCOMM_WSIZE_5; break;
	74	}
	75	if (cflag & CSTOPB)
	76	cval \|= IRCOMM_2_STOP_BIT;
6819bc2e	77
1da177e4 LT	78	if (cflag & PARENB)
	79	cval \|= IRCOMM_PARITY_ENABLE;
	80	if (!(cflag & PARODD))
	81	cval \|= IRCOMM_PARITY_EVEN;
	82
	83	/* Determine divisor based on baud rate */
	84	baud = tty_get_baud_rate(self->tty);
	85	if (!baud)
	86	baud = 9600; /* B0 transition handled in rs_set_termios */
	87
	88	self->settings.data_rate = baud;
	89	ircomm_param_request(self, IRCOMM_DATA_RATE, FALSE);
6819bc2e	90
1da177e4 LT	91	/* CTS flow control flag and modem status interrupts */
	92	if (cflag & CRTSCTS) {
	93	self->flags \|= ASYNC_CTS_FLOW;
	94	self->settings.flow_control \|= IRCOMM_RTS_CTS_IN;
	95	/* This got me. Bummer. Jean II */
	96	if (self->service_type == IRCOMM_3_WIRE_RAW)
0dc47877	97	IRDA_WARNING("%s(), enabling RTS/CTS on link that doesn't support it (3-wire-raw)\n", __func__);
1da177e4 LT	98	} else {
	99	self->flags &= ~ASYNC_CTS_FLOW;
	100	self->settings.flow_control &= ~IRCOMM_RTS_CTS_IN;
	101	}
	102	if (cflag & CLOCAL)
	103	self->flags &= ~ASYNC_CHECK_CD;
	104	else
	105	self->flags \|= ASYNC_CHECK_CD;
6819bc2e	106	#if 0
1da177e4 LT	107	/*
	108	* Set up parity check flag
	109	*/
	110
	111	if (I_INPCK(self->tty))
	112	driver->read_status_mask \|= LSR_FE \| LSR_PE;
	113	if (I_BRKINT(driver->tty) \|\| I_PARMRK(driver->tty))
	114	driver->read_status_mask \|= LSR_BI;
6819bc2e	115
1da177e4 LT	116	/*
	117	* Characters to ignore
	118	*/
	119	driver->ignore_status_mask = 0;
	120	if (I_IGNPAR(driver->tty))
	121	driver->ignore_status_mask \|= LSR_PE \| LSR_FE;
	122
	123	if (I_IGNBRK(self->tty)) {
	124	self->ignore_status_mask \|= LSR_BI;
	125	/*
6819bc2e	126	* If we're ignore parity and break indicators, ignore
1da177e4 LT	127	* overruns too. (For real raw support).
1da177e4 LT	128	*/
6819bc2e	129	if (I_IGNPAR(self->tty))
1da177e4 LT	130	self->ignore_status_mask \|= LSR_OE;
	131	}
	132	#endif
	133	self->settings.data_format = cval;
	134
	135	ircomm_param_request(self, IRCOMM_DATA_FORMAT, FALSE);
6819bc2e	136	ircomm_param_request(self, IRCOMM_FLOW_CONTROL, TRUE);
1da177e4 LT	137	}
	138
	139	/*
	140	* Function ircomm_tty_set_termios (tty, old_termios)
	141	*
	142	* This routine allows the tty driver to be notified when device's
	143	* termios settings have changed. Note that a well-designed tty driver
	144	* should be prepared to accept the case where old == NULL, and try to
	145	* do something rational.
	146	*/
6819bc2e	147	void ircomm_tty_set_termios(struct tty_struct *tty,
edc6afc5	148	struct ktermios *old_termios)
1da177e4 LT	149	{
	150	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) tty->driver_data;
	151	unsigned int cflag = tty->termios->c_cflag;
	152
0dc47877	153	IRDA_DEBUG(2, "%s()\n", __func__ );
1da177e4	154
6819bc2e YH	155	if ((cflag == old_termios->c_cflag) &&
6819bc2e YH	156	(RELEVANT_IFLAG(tty->termios->c_iflag) ==
1da177e4 LT	157	RELEVANT_IFLAG(old_termios->c_iflag)))
	158	{
	159	return;
	160	}
	161
	162	ircomm_tty_change_speed(self);
	163
	164	/* Handle transition to B0 status */
	165	if ((old_termios->c_cflag & CBAUD) &&
	166	!(cflag & CBAUD)) {
	167	self->settings.dte &= ~(IRCOMM_DTR\|IRCOMM_RTS);
	168	ircomm_param_request(self, IRCOMM_DTE, TRUE);
	169	}
6819bc2e	170
1da177e4 LT	171	/* Handle transition away from B0 status */
	172	if (!(old_termios->c_cflag & CBAUD) &&
	173	(cflag & CBAUD)) {
	174	self->settings.dte \|= IRCOMM_DTR;
6819bc2e	175	if (!(tty->termios->c_cflag & CRTSCTS) \|\|
1da177e4 LT	176	!test_bit(TTY_THROTTLED, &tty->flags)) {
	177	self->settings.dte \|= IRCOMM_RTS;
	178	}
	179	ircomm_param_request(self, IRCOMM_DTE, TRUE);
	180	}
6819bc2e	181
1da177e4 LT	182	/* Handle turning off CRTSCTS */
1da177e4 LT	183	if ((old_termios->c_cflag & CRTSCTS) &&
6819bc2e	184	!(tty->termios->c_cflag & CRTSCTS))
1da177e4 LT	185	{
	186	tty->hw_stopped = 0;
	187	ircomm_tty_start(tty);
	188	}
	189	}
	190
	191	/*
	192	* Function ircomm_tty_tiocmget (tty, file)
	193	*
6819bc2e	194	*
1da177e4 LT	195	*
	196	*/
	197	int ircomm_tty_tiocmget(struct tty_struct tty, struct file file)
	198	{
	199	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) tty->driver_data;
	200	unsigned int result;
	201
0dc47877	202	IRDA_DEBUG(2, "%s()\n", __func__ );
1da177e4 LT	203
	204	if (tty->flags & (1 << TTY_IO_ERROR))
	205	return -EIO;
	206
	207	result = ((self->settings.dte & IRCOMM_RTS) ? TIOCM_RTS : 0)
	208	\| ((self->settings.dte & IRCOMM_DTR) ? TIOCM_DTR : 0)
	209	\| ((self->settings.dce & IRCOMM_CD) ? TIOCM_CAR : 0)
	210	\| ((self->settings.dce & IRCOMM_RI) ? TIOCM_RNG : 0)
	211	\| ((self->settings.dce & IRCOMM_DSR) ? TIOCM_DSR : 0)
	212	\| ((self->settings.dce & IRCOMM_CTS) ? TIOCM_CTS : 0);
	213	return result;
	214	}
	215
	216	/*
	217	* Function ircomm_tty_tiocmset (tty, file, set, clear)
	218	*
6819bc2e	219	*
1da177e4 LT	220	*
	221	*/
	222	int ircomm_tty_tiocmset(struct tty_struct tty, struct file file,
	223	unsigned int set, unsigned int clear)
6819bc2e	224	{
1da177e4 LT	225	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) tty->driver_data;
1da177e4 LT	226
0dc47877	227	IRDA_DEBUG(2, "%s()\n", __func__ );
1da177e4 LT	228
	229	if (tty->flags & (1 << TTY_IO_ERROR))
	230	return -EIO;
	231
	232	IRDA_ASSERT(self != NULL, return -1;);
	233	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
	234
	235	if (set & TIOCM_RTS)
	236	self->settings.dte \|= IRCOMM_RTS;
	237	if (set & TIOCM_DTR)
	238	self->settings.dte \|= IRCOMM_DTR;
	239
	240	if (clear & TIOCM_RTS)
	241	self->settings.dte &= ~IRCOMM_RTS;
	242	if (clear & TIOCM_DTR)
	243	self->settings.dte &= ~IRCOMM_DTR;
	244
	245	if ((set\|clear) & TIOCM_RTS)
	246	self->settings.dte \|= IRCOMM_DELTA_RTS;
	247	if ((set\|clear) & TIOCM_DTR)
	248	self->settings.dte \|= IRCOMM_DELTA_DTR;
	249
	250	ircomm_param_request(self, IRCOMM_DTE, TRUE);
6819bc2e	251
1da177e4 LT	252	return 0;
	253	}
	254
	255	/*
	256	* Function get_serial_info (driver, retinfo)
	257	*
6819bc2e	258	*
1da177e4 LT	259	*
	260	*/
	261	static int ircomm_tty_get_serial_info(struct ircomm_tty_cb *self,
	262	struct serial_struct __user *retinfo)
	263	{
	264	struct serial_struct info;
6819bc2e	265
1da177e4 LT	266	if (!retinfo)
	267	return -EFAULT;
	268
0dc47877	269	IRDA_DEBUG(2, "%s()\n", __func__ );
1da177e4 LT	270
	271	memset(&info, 0, sizeof(info));
	272	info.line = self->line;
	273	info.flags = self->flags;
	274	info.baud_base = self->settings.data_rate;
	275	info.close_delay = self->close_delay;
	276	info.closing_wait = self->closing_wait;
	277
	278	/* For compatibility */
6819bc2e YH	279	info.type = PORT_16550A;
	280	info.port = 0;
	281	info.irq = 0;
1da177e4	282	info.xmit_fifo_size = 0;
6819bc2e	283	info.hub6 = 0;
1da177e4 LT	284	info.custom_divisor = 0;
	285
	286	if (copy_to_user(retinfo, &info, sizeof(*retinfo)))
	287	return -EFAULT;
	288
	289	return 0;
	290	}
	291
	292	/*
	293	* Function set_serial_info (driver, new_info)
	294	*
6819bc2e	295	*
1da177e4 LT	296	*
	297	*/
	298	static int ircomm_tty_set_serial_info(struct ircomm_tty_cb *self,
	299	struct serial_struct __user *new_info)
	300	{
	301	#if 0
	302	struct serial_struct new_serial;
	303	struct ircomm_tty_cb old_state, *state;
	304
0dc47877	305	IRDA_DEBUG(0, "%s()\n", __func__ );
1da177e4 LT	306
	307	if (copy_from_user(&new_serial,new_info,sizeof(new_serial)))
	308	return -EFAULT;
	309
	310
	311	state = self
	312	old_state = *self;
6819bc2e	313
1da177e4 LT	314	if (!capable(CAP_SYS_ADMIN)) {
	315	if ((new_serial.baud_base != state->settings.data_rate) \|\|
	316	(new_serial.close_delay != state->close_delay) \|\|
	317	((new_serial.flags & ~ASYNC_USR_MASK) !=
	318	(self->flags & ~ASYNC_USR_MASK)))
	319	return -EPERM;
	320	state->flags = ((state->flags & ~ASYNC_USR_MASK) \|
	321	(new_serial.flags & ASYNC_USR_MASK));
	322	self->flags = ((self->flags & ~ASYNC_USR_MASK) \|
	323	(new_serial.flags & ASYNC_USR_MASK));
	324	/* self->custom_divisor = new_serial.custom_divisor; */
	325	goto check_and_exit;
	326	}
	327
	328	/*
	329	* OK, past this point, all the error checking has been done.
	330	* At this point, we start making changes.....
	331	*/
	332
	333	if (self->settings.data_rate != new_serial.baud_base) {
	334	self->settings.data_rate = new_serial.baud_base;
	335	ircomm_param_request(self, IRCOMM_DATA_RATE, TRUE);
	336	}
	337
	338	self->close_delay = new_serial.close_delay * HZ/100;
	339	self->closing_wait = new_serial.closing_wait * HZ/100;
	340	/* self->custom_divisor = new_serial.custom_divisor; */
	341
	342	self->flags = ((self->flags & ~ASYNC_FLAGS) \|
	343	(new_serial.flags & ASYNC_FLAGS));
	344	self->tty->low_latency = (self->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
	345
	346	check_and_exit:
	347
	348	if (self->flags & ASYNC_INITIALIZED) {
	349	if (((old_state.flags & ASYNC_SPD_MASK) !=
	350	(self->flags & ASYNC_SPD_MASK)) \|\|
	351	(old_driver.custom_divisor != driver->custom_divisor)) {
	352	if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
	353	driver->tty->alt_speed = 57600;
	354	if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
	355	driver->tty->alt_speed = 115200;
	356	if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
	357	driver->tty->alt_speed = 230400;
	358	if ((driver->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
	359	driver->tty->alt_speed = 460800;
	360	ircomm_tty_change_speed(driver);
	361	}
	362	}
	363	#endif
	364	return 0;
	365	}
	366
	367	/*
	368	* Function ircomm_tty_ioctl (tty, file, cmd, arg)
	369	*
6819bc2e	370	*
1da177e4 LT	371	*
1da177e4 LT	372	*/
6819bc2e	373	int ircomm_tty_ioctl(struct tty_struct tty, struct file file,
1da177e4 LT	374	unsigned int cmd, unsigned long arg)
	375	{
	376	struct ircomm_tty_cb self = (struct ircomm_tty_cb ) tty->driver_data;
	377	int ret = 0;
	378
0dc47877	379	IRDA_DEBUG(2, "%s()\n", __func__ );
1da177e4 LT	380
	381	if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) &&
	382	(cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) &&
	383	(cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) {
	384	if (tty->flags & (1 << TTY_IO_ERROR))
	385	return -EIO;
	386	}
	387
	388	switch (cmd) {
	389	case TIOCGSERIAL:
	390	ret = ircomm_tty_get_serial_info(self, (struct serial_struct __user *) arg);
	391	break;
	392	case TIOCSSERIAL:
	393	ret = ircomm_tty_set_serial_info(self, (struct serial_struct __user *) arg);
	394	break;
	395	case TIOCMIWAIT:
	396	IRDA_DEBUG(0, "(), TIOCMIWAIT, not impl!\n");
	397	break;
	398
	399	case TIOCGICOUNT:
0dc47877	400	IRDA_DEBUG(0, "%s(), TIOCGICOUNT not impl!\n", __func__ );
1da177e4 LT	401	#if 0
	402	save_flags(flags); cli();
	403	cnow = driver->icount;
	404	restore_flags(flags);
	405	p_cuser = (struct serial_icounter_struct __user *) arg;
	406	if (put_user(cnow.cts, &p_cuser->cts) \|\|
	407	put_user(cnow.dsr, &p_cuser->dsr) \|\|
	408	put_user(cnow.rng, &p_cuser->rng) \|\|
	409	put_user(cnow.dcd, &p_cuser->dcd) \|\|
	410	put_user(cnow.rx, &p_cuser->rx) \|\|
	411	put_user(cnow.tx, &p_cuser->tx) \|\|
	412	put_user(cnow.frame, &p_cuser->frame) \|\|
	413	put_user(cnow.overrun, &p_cuser->overrun) \|\|
	414	put_user(cnow.parity, &p_cuser->parity) \|\|
	415	put_user(cnow.brk, &p_cuser->brk) \|\|
	416	put_user(cnow.buf_overrun, &p_cuser->buf_overrun))
	417	return -EFAULT;
6819bc2e	418	#endif
1da177e4 LT	419	return 0;
	420	default:
	421	ret = -ENOIOCTLCMD; /* ioctls which we must ignore */
	422	}
	423	return ret;
	424	}
	425
	426
	427