![Alan Cox](/assets/img/avatar_default.png)
This is the core of the switch to the new framework. I've split it from the driver patches which are mostly search/replace and would encourage people to give this one a good hard stare. The references to BOTHER and ISHIFT are the termios values that must be defined by a platform once it wants to turn on "new style" ioctl support. The code patches here ensure that providing 1. The termios overlays the ktermios in memory 2. The only new kernel only fields are c_ispeed/c_ospeed (or none) the existing behaviour is retained. This is true for the patches at this point in time. Future patches will define BOTHER, ISHIFT and enable newer termios structures for each architecture, and once they are all done some of the ifdefs also vanish. [akpm@osdl.org: warning fix] [akpm@osdl.org: IRDA fix] Signed-off-by: Alan Cox <alan@redhat.com> Signed-off-by: Andrew Morton <akpm@osdl.org> Signed-off-by: Linus Torvalds <torvalds@osdl.org>
429 lines
12 KiB
C
429 lines
12 KiB
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/sched.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", __FUNCTION__ );
|
|
|
|
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", __FUNCTION__);
|
|
} 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", __FUNCTION__ );
|
|
|
|
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", __FUNCTION__ );
|
|
|
|
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", __FUNCTION__ );
|
|
|
|
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", __FUNCTION__ );
|
|
|
|
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", __FUNCTION__ );
|
|
|
|
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", __FUNCTION__ );
|
|
|
|
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", __FUNCTION__ );
|
|
#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;
|
|
}
|
|
|
|
|
|
|