forked from Minki/linux
Char: moxa, rework open/close
- add locking to open/close/hangup and ioctl (tiocm) - add pci hot-un-plug support (hangup on board remove, wait for openers) - cleanup block_till_ready - move close code common to close/hangup into separate function to be able to call it from open when hangup occurs while block_till_ready - let ldisc flush on tty layer, it will do it after we return Signed-off-by: Jiri Slaby <jirislaby@gmail.com> Tested-by: Oyvind Aabling <Oyvind.Aabling@uni-c.dk> Signed-off-by: Andrew Morton <akpm@linux-foundation.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Jiri Slaby
Linus Torvalds
parent
2a5413416b
commit
a8f5cda067
@ -42,7 +42,6 @@
|
||||
#include <linux/pci.h>
|
||||
#include <linux/init.h>
|
||||
#include <linux/bitops.h>
|
||||
#include <linux/completion.h>
|
||||
|
||||
#include <asm/system.h>
|
||||
#include <asm/io.h>
|
||||
@ -134,13 +133,11 @@ struct moxa_port {
|
||||
|
||||
int type;
|
||||
int close_delay;
|
||||
int count;
|
||||
int blocked_open;
|
||||
unsigned int count;
|
||||
int asyncflags;
|
||||
int cflag;
|
||||
unsigned long statusflags;
|
||||
wait_queue_head_t open_wait;
|
||||
struct completion close_wait;
|
||||
|
||||
u8 DCDState;
|
||||
u8 lineCtrl;
|
||||
@ -167,6 +164,7 @@ static int ttymajor = MOXAMAJOR;
|
||||
static struct mon_str moxaLog;
|
||||
static unsigned int moxaFuncTout = HZ / 2;
|
||||
static unsigned int moxaLowWaterChk;
|
||||
static DEFINE_MUTEX(moxa_openlock);
|
||||
/* Variables for insmod */
|
||||
#ifdef MODULE
|
||||
static unsigned long baseaddr[MAX_BOARDS];
|
||||
@ -209,8 +207,6 @@ static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
|
||||
unsigned int set, unsigned int clear);
|
||||
static void moxa_poll(unsigned long);
|
||||
static void moxa_set_tty_param(struct tty_struct *, struct ktermios *);
|
||||
static int moxa_block_till_ready(struct tty_struct *, struct file *,
|
||||
struct moxa_port *);
|
||||
static void moxa_setup_empty_event(struct tty_struct *);
|
||||
static void moxa_shut_down(struct moxa_port *);
|
||||
/*
|
||||
@ -280,7 +276,7 @@ static int moxa_ioctl(struct tty_struct *tty, struct file *file,
|
||||
{
|
||||
struct moxa_port *ch = tty->driver_data;
|
||||
void __user *argp = (void __user *)arg;
|
||||
int status;
|
||||
int status, ret = 0;
|
||||
|
||||
if (tty->index == MAX_PORTS) {
|
||||
if (cmd != MOXA_GETDATACOUNT && cmd != MOXA_GET_IOQUEUE &&
|
||||
@ -292,17 +288,19 @@ static int moxa_ioctl(struct tty_struct *tty, struct file *file,
|
||||
switch (cmd) {
|
||||
case MOXA_GETDATACOUNT:
|
||||
moxaLog.tick = jiffies;
|
||||
return copy_to_user(argp, &moxaLog, sizeof(moxaLog)) ?
|
||||
-EFAULT : 0;
|
||||
if (copy_to_user(argp, &moxaLog, sizeof(moxaLog)))
|
||||
ret = -EFAULT;
|
||||
break;
|
||||
case MOXA_FLUSH_QUEUE:
|
||||
MoxaPortFlushData(ch, arg);
|
||||
return 0;
|
||||
break;
|
||||
case MOXA_GET_IOQUEUE: {
|
||||
struct moxaq_str __user *argm = argp;
|
||||
struct moxaq_str tmp;
|
||||
struct moxa_port *p;
|
||||
unsigned int i, j;
|
||||
|
||||
mutex_lock(&moxa_openlock);
|
||||
for (i = 0; i < MAX_BOARDS; i++) {
|
||||
p = moxa_boards[i].ports;
|
||||
for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
|
||||
@ -311,23 +309,29 @@ static int moxa_ioctl(struct tty_struct *tty, struct file *file,
|
||||
tmp.inq = MoxaPortRxQueue(p);
|
||||
tmp.outq = MoxaPortTxQueue(p);
|
||||
}
|
||||
if (copy_to_user(argm, &tmp, sizeof(tmp)))
|
||||
if (copy_to_user(argm, &tmp, sizeof(tmp))) {
|
||||
mutex_unlock(&moxa_openlock);
|
||||
return -EFAULT;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
mutex_unlock(&moxa_openlock);
|
||||
break;
|
||||
} case MOXA_GET_OQUEUE:
|
||||
status = MoxaPortTxQueue(ch);
|
||||
return put_user(status, (unsigned long __user *)argp);
|
||||
ret = put_user(status, (unsigned long __user *)argp);
|
||||
break;
|
||||
case MOXA_GET_IQUEUE:
|
||||
status = MoxaPortRxQueue(ch);
|
||||
return put_user(status, (unsigned long __user *)argp);
|
||||
ret = put_user(status, (unsigned long __user *)argp);
|
||||
break;
|
||||
case MOXA_GETMSTATUS: {
|
||||
struct mxser_mstatus __user *argm = argp;
|
||||
struct mxser_mstatus tmp;
|
||||
struct moxa_port *p;
|
||||
unsigned int i, j;
|
||||
|
||||
mutex_lock(&moxa_openlock);
|
||||
for (i = 0; i < MAX_BOARDS; i++) {
|
||||
p = moxa_boards[i].ports;
|
||||
for (j = 0; j < MAX_PORTS_PER_BOARD; j++, p++, argm++) {
|
||||
@ -348,18 +352,29 @@ static int moxa_ioctl(struct tty_struct *tty, struct file *file,
|
||||
else
|
||||
tmp.cflag = p->tty->termios->c_cflag;
|
||||
copy:
|
||||
if (copy_to_user(argm, &tmp, sizeof(tmp)))
|
||||
if (copy_to_user(argm, &tmp, sizeof(tmp))) {
|
||||
mutex_unlock(&moxa_openlock);
|
||||
return -EFAULT;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
mutex_unlock(&moxa_openlock);
|
||||
break;
|
||||
}
|
||||
case TIOCGSERIAL:
|
||||
return moxa_get_serial_info(ch, argp);
|
||||
mutex_lock(&moxa_openlock);
|
||||
ret = moxa_get_serial_info(ch, argp);
|
||||
mutex_unlock(&moxa_openlock);
|
||||
break;
|
||||
case TIOCSSERIAL:
|
||||
return moxa_set_serial_info(ch, argp);
|
||||
mutex_lock(&moxa_openlock);
|
||||
ret = moxa_set_serial_info(ch, argp);
|
||||
mutex_unlock(&moxa_openlock);
|
||||
break;
|
||||
default:
|
||||
ret = -ENOIOCTLCMD;
|
||||
}
|
||||
return -ENOIOCTLCMD;
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void moxa_break_ctl(struct tty_struct *tty, int state)
|
||||
@ -817,7 +832,6 @@ static int moxa_init_board(struct moxa_board_conf *brd, struct device *dev)
|
||||
p->close_delay = 5 * HZ / 10;
|
||||
p->cflag = B9600 | CS8 | CREAD | CLOCAL | HUPCL;
|
||||
init_waitqueue_head(&p->open_wait);
|
||||
init_completion(&p->close_wait);
|
||||
}
|
||||
|
||||
switch (brd->boardType) {
|
||||
@ -861,9 +875,29 @@ err:
|
||||
|
||||
static void moxa_board_deinit(struct moxa_board_conf *brd)
|
||||
{
|
||||
unsigned int a, opened;
|
||||
|
||||
mutex_lock(&moxa_openlock);
|
||||
spin_lock_bh(&moxa_lock);
|
||||
brd->ready = 0;
|
||||
spin_unlock_bh(&moxa_lock);
|
||||
|
||||
/* pci hot-un-plug support */
|
||||
for (a = 0; a < brd->numPorts; a++)
|
||||
if (brd->ports[a].asyncflags & ASYNC_INITIALIZED)
|
||||
tty_hangup(brd->ports[a].tty);
|
||||
while (1) {
|
||||
opened = 0;
|
||||
for (a = 0; a < brd->numPorts; a++)
|
||||
if (brd->ports[a].asyncflags & ASYNC_INITIALIZED)
|
||||
opened++;
|
||||
mutex_unlock(&moxa_openlock);
|
||||
if (!opened)
|
||||
break;
|
||||
msleep(50);
|
||||
mutex_lock(&moxa_openlock);
|
||||
}
|
||||
|
||||
iounmap(brd->basemem);
|
||||
brd->basemem = NULL;
|
||||
kfree(brd->ports);
|
||||
@ -1061,6 +1095,49 @@ static void __exit moxa_exit(void)
|
||||
module_init(moxa_init);
|
||||
module_exit(moxa_exit);
|
||||
|
||||
static void moxa_close_port(struct moxa_port *ch)
|
||||
{
|
||||
moxa_shut_down(ch);
|
||||
MoxaPortFlushData(ch, 2);
|
||||
ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
|
||||
ch->tty->driver_data = NULL;
|
||||
ch->tty = NULL;
|
||||
}
|
||||
|
||||
static int moxa_block_till_ready(struct tty_struct *tty, struct file *filp,
|
||||
struct moxa_port *ch)
|
||||
{
|
||||
DEFINE_WAIT(wait);
|
||||
int retval = 0;
|
||||
u8 dcd;
|
||||
|
||||
while (1) {
|
||||
prepare_to_wait(&ch->open_wait, &wait, TASK_INTERRUPTIBLE);
|
||||
if (tty_hung_up_p(filp)) {
|
||||
#ifdef SERIAL_DO_RESTART
|
||||
retval = -ERESTARTSYS;
|
||||
#else
|
||||
retval = -EAGAIN;
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
spin_lock_bh(&moxa_lock);
|
||||
dcd = ch->DCDState;
|
||||
spin_unlock_bh(&moxa_lock);
|
||||
if (dcd)
|
||||
break;
|
||||
|
||||
if (signal_pending(current)) {
|
||||
retval = -ERESTARTSYS;
|
||||
break;
|
||||
}
|
||||
schedule();
|
||||
}
|
||||
finish_wait(&ch->open_wait, &wait);
|
||||
|
||||
return retval;
|
||||
}
|
||||
|
||||
static int moxa_open(struct tty_struct *tty, struct file *filp)
|
||||
{
|
||||
struct moxa_board_conf *brd;
|
||||
@ -1072,9 +1149,13 @@ static int moxa_open(struct tty_struct *tty, struct file *filp)
|
||||
if (port == MAX_PORTS) {
|
||||
return capable(CAP_SYS_ADMIN) ? 0 : -EPERM;
|
||||
}
|
||||
if (mutex_lock_interruptible(&moxa_openlock))
|
||||
return -ERESTARTSYS;
|
||||
brd = &moxa_boards[port / MAX_PORTS_PER_BOARD];
|
||||
if (!brd->ready)
|
||||
if (!brd->ready) {
|
||||
mutex_unlock(&moxa_openlock);
|
||||
return -ENODEV;
|
||||
}
|
||||
|
||||
ch = &brd->ports[port % MAX_PORTS_PER_BOARD];
|
||||
ch->count++;
|
||||
@ -1085,19 +1166,24 @@ static int moxa_open(struct tty_struct *tty, struct file *filp)
|
||||
moxa_set_tty_param(tty, tty->termios);
|
||||
MoxaPortLineCtrl(ch, 1, 1);
|
||||
MoxaPortEnable(ch);
|
||||
MoxaSetFifo(ch, ch->type == PORT_16550A);
|
||||
ch->asyncflags |= ASYNC_INITIALIZED;
|
||||
}
|
||||
retval = moxa_block_till_ready(tty, filp, ch);
|
||||
mutex_unlock(&moxa_openlock);
|
||||
|
||||
moxa_unthrottle(tty);
|
||||
retval = 0;
|
||||
if (!(filp->f_flags & O_NONBLOCK) && !C_CLOCAL(tty))
|
||||
retval = moxa_block_till_ready(tty, filp, ch);
|
||||
mutex_lock(&moxa_openlock);
|
||||
if (retval) {
|
||||
if (ch->count) /* 0 means already hung up... */
|
||||
if (--ch->count == 0)
|
||||
moxa_close_port(ch);
|
||||
} else
|
||||
ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
|
||||
mutex_unlock(&moxa_openlock);
|
||||
|
||||
if (ch->type == PORT_16550A) {
|
||||
MoxaSetFifo(ch, 1);
|
||||
} else {
|
||||
MoxaSetFifo(ch, 0);
|
||||
}
|
||||
|
||||
return (retval);
|
||||
return retval;
|
||||
}
|
||||
|
||||
static void moxa_close(struct tty_struct *tty, struct file *filp)
|
||||
@ -1106,18 +1192,14 @@ static void moxa_close(struct tty_struct *tty, struct file *filp)
|
||||
int port;
|
||||
|
||||
port = tty->index;
|
||||
if (port == MAX_PORTS) {
|
||||
if (port == MAX_PORTS || tty_hung_up_p(filp))
|
||||
return;
|
||||
}
|
||||
if (tty->driver_data == NULL) {
|
||||
return;
|
||||
}
|
||||
if (tty_hung_up_p(filp)) {
|
||||
return;
|
||||
}
|
||||
ch = (struct moxa_port *) tty->driver_data;
|
||||
|
||||
if ((tty->count == 1) && (ch->count != 1)) {
|
||||
mutex_lock(&moxa_openlock);
|
||||
ch = tty->driver_data;
|
||||
if (ch == NULL)
|
||||
goto unlock;
|
||||
if (tty->count == 1 && ch->count != 1) {
|
||||
printk(KERN_WARNING "moxa_close: bad serial port count; "
|
||||
"tty->count is 1, ch->count is %d\n", ch->count);
|
||||
ch->count = 1;
|
||||
@ -1127,33 +1209,18 @@ static void moxa_close(struct tty_struct *tty, struct file *filp)
|
||||
"device=%s\n", tty->name);
|
||||
ch->count = 0;
|
||||
}
|
||||
if (ch->count) {
|
||||
return;
|
||||
}
|
||||
ch->asyncflags |= ASYNC_CLOSING;
|
||||
if (ch->count)
|
||||
goto unlock;
|
||||
|
||||
ch->cflag = tty->termios->c_cflag;
|
||||
if (ch->asyncflags & ASYNC_INITIALIZED) {
|
||||
moxa_setup_empty_event(tty);
|
||||
tty_wait_until_sent(tty, 30 * HZ); /* 30 seconds timeout */
|
||||
}
|
||||
moxa_shut_down(ch);
|
||||
MoxaPortFlushData(ch, 2);
|
||||
|
||||
if (tty->driver->flush_buffer)
|
||||
tty->driver->flush_buffer(tty);
|
||||
tty_ldisc_flush(tty);
|
||||
|
||||
tty->closing = 0;
|
||||
ch->tty = NULL;
|
||||
if (ch->blocked_open) {
|
||||
if (ch->close_delay) {
|
||||
msleep_interruptible(jiffies_to_msecs(ch->close_delay));
|
||||
}
|
||||
wake_up_interruptible(&ch->open_wait);
|
||||
}
|
||||
ch->asyncflags &= ~(ASYNC_NORMAL_ACTIVE | ASYNC_CLOSING);
|
||||
complete_all(&ch->close_wait);
|
||||
moxa_close_port(ch);
|
||||
unlock:
|
||||
mutex_unlock(&moxa_openlock);
|
||||
}
|
||||
|
||||
static int moxa_write(struct tty_struct *tty,
|
||||
@ -1249,11 +1316,15 @@ static void moxa_put_char(struct tty_struct *tty, unsigned char c)
|
||||
|
||||
static int moxa_tiocmget(struct tty_struct *tty, struct file *file)
|
||||
{
|
||||
struct moxa_port *ch = tty->driver_data;
|
||||
struct moxa_port *ch;
|
||||
int flag = 0, dtr, rts;
|
||||
|
||||
if (!ch)
|
||||
mutex_lock(&moxa_openlock);
|
||||
ch = tty->driver_data;
|
||||
if (!ch) {
|
||||
mutex_unlock(&moxa_openlock);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
MoxaPortGetLineOut(ch, &dtr, &rts);
|
||||
if (dtr)
|
||||
@ -1267,19 +1338,24 @@ static int moxa_tiocmget(struct tty_struct *tty, struct file *file)
|
||||
flag |= TIOCM_DSR;
|
||||
if (dtr & 4)
|
||||
flag |= TIOCM_CD;
|
||||
mutex_unlock(&moxa_openlock);
|
||||
return flag;
|
||||
}
|
||||
|
||||
static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
|
||||
unsigned int set, unsigned int clear)
|
||||
{
|
||||
struct moxa_port *ch = tty->driver_data;
|
||||
struct moxa_port *ch;
|
||||
int port;
|
||||
int dtr, rts;
|
||||
|
||||
port = tty->index;
|
||||
if (!ch)
|
||||
mutex_lock(&moxa_openlock);
|
||||
ch = tty->driver_data;
|
||||
if (!ch) {
|
||||
mutex_unlock(&moxa_openlock);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
MoxaPortGetLineOut(ch, &dtr, &rts);
|
||||
if (set & TIOCM_RTS)
|
||||
@ -1291,6 +1367,7 @@ static int moxa_tiocmset(struct tty_struct *tty, struct file *file,
|
||||
if (clear & TIOCM_DTR)
|
||||
dtr = 0;
|
||||
MoxaPortLineCtrl(ch, dtr, rts);
|
||||
mutex_unlock(&moxa_openlock);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1348,13 +1425,18 @@ static void moxa_start(struct tty_struct *tty)
|
||||
|
||||
static void moxa_hangup(struct tty_struct *tty)
|
||||
{
|
||||
struct moxa_port *ch = (struct moxa_port *) tty->driver_data;
|
||||
struct moxa_port *ch;
|
||||
|
||||
moxa_flush_buffer(tty);
|
||||
moxa_shut_down(ch);
|
||||
mutex_lock(&moxa_openlock);
|
||||
ch = tty->driver_data;
|
||||
if (ch == NULL) {
|
||||
mutex_unlock(&moxa_openlock);
|
||||
return;
|
||||
}
|
||||
ch->count = 0;
|
||||
ch->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
|
||||
ch->tty = NULL;
|
||||
moxa_close_port(ch);
|
||||
mutex_unlock(&moxa_openlock);
|
||||
|
||||
wake_up_interruptible(&ch->open_wait);
|
||||
}
|
||||
|
||||
@ -1363,11 +1445,8 @@ static void moxa_new_dcdstate(struct moxa_port *p, u8 dcd)
|
||||
dcd = !!dcd;
|
||||
|
||||
if ((dcd != p->DCDState) && p->tty && C_CLOCAL(p->tty)) {
|
||||
if (!dcd) {
|
||||
if (!dcd)
|
||||
tty_hangup(p->tty);
|
||||
p->asyncflags &= ~ASYNC_NORMAL_ACTIVE;
|
||||
}
|
||||
wake_up_interruptible(&p->open_wait);
|
||||
}
|
||||
p->DCDState = dcd;
|
||||
}
|
||||
@ -1499,91 +1578,6 @@ static void moxa_set_tty_param(struct tty_struct *tty, struct ktermios *old_term
|
||||
tty_encode_baud_rate(tty, baud, baud);
|
||||
}
|
||||
|
||||
static int moxa_block_till_ready(struct tty_struct *tty, struct file *filp,
|
||||
struct moxa_port *ch)
|
||||
{
|
||||
DECLARE_WAITQUEUE(wait,current);
|
||||
int retval;
|
||||
int do_clocal = C_CLOCAL(tty);
|
||||
|
||||
/*
|
||||
* If the device is in the middle of being closed, then block
|
||||
* until it's done, and then try again.
|
||||
*/
|
||||
if (tty_hung_up_p(filp) || (ch->asyncflags & ASYNC_CLOSING)) {
|
||||
if (ch->asyncflags & ASYNC_CLOSING)
|
||||
wait_for_completion_interruptible(&ch->close_wait);
|
||||
#ifdef SERIAL_DO_RESTART
|
||||
if (ch->asyncflags & ASYNC_HUP_NOTIFY)
|
||||
return (-EAGAIN);
|
||||
else
|
||||
return (-ERESTARTSYS);
|
||||
#else
|
||||
return (-EAGAIN);
|
||||
#endif
|
||||
}
|
||||
/*
|
||||
* If non-blocking mode is set, then make the check up front
|
||||
* and then exit.
|
||||
*/
|
||||
if (filp->f_flags & O_NONBLOCK) {
|
||||
ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
|
||||
return (0);
|
||||
}
|
||||
/*
|
||||
* Block waiting for the carrier detect and the line to become free
|
||||
*/
|
||||
retval = 0;
|
||||
add_wait_queue(&ch->open_wait, &wait);
|
||||
pr_debug("block_til_ready before block: ttys%d, count = %d\n",
|
||||
tty->index, ch->count);
|
||||
spin_lock_bh(&moxa_lock);
|
||||
if (!tty_hung_up_p(filp))
|
||||
ch->count--;
|
||||
ch->blocked_open++;
|
||||
spin_unlock_bh(&moxa_lock);
|
||||
|
||||
while (1) {
|
||||
set_current_state(TASK_INTERRUPTIBLE);
|
||||
if (tty_hung_up_p(filp) ||
|
||||
!(ch->asyncflags & ASYNC_INITIALIZED)) {
|
||||
#ifdef SERIAL_DO_RESTART
|
||||
if (ch->asyncflags & ASYNC_HUP_NOTIFY)
|
||||
retval = -EAGAIN;
|
||||
else
|
||||
retval = -ERESTARTSYS;
|
||||
#else
|
||||
retval = -EAGAIN;
|
||||
#endif
|
||||
break;
|
||||
}
|
||||
if (!(ch->asyncflags & ASYNC_CLOSING) && (do_clocal ||
|
||||
ch->DCDState))
|
||||
break;
|
||||
|
||||
if (signal_pending(current)) {
|
||||
retval = -ERESTARTSYS;
|
||||
break;
|
||||
}
|
||||
schedule();
|
||||
}
|
||||
set_current_state(TASK_RUNNING);
|
||||
remove_wait_queue(&ch->open_wait, &wait);
|
||||
|
||||
spin_lock_bh(&moxa_lock);
|
||||
if (!tty_hung_up_p(filp))
|
||||
ch->count++;
|
||||
ch->blocked_open--;
|
||||
spin_unlock_bh(&moxa_lock);
|
||||
pr_debug("block_til_ready after blocking: ttys%d, count = %d\n",
|
||||
tty->index, ch->count);
|
||||
if (retval)
|
||||
return (retval);
|
||||
/* FIXME: review to see if we need to use set_bit on these */
|
||||
ch->asyncflags |= ASYNC_NORMAL_ACTIVE;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void moxa_setup_empty_event(struct tty_struct *tty)
|
||||
{
|
||||
struct moxa_port *ch = tty->driver_data;
|
||||
@ -1595,22 +1589,22 @@ static void moxa_setup_empty_event(struct tty_struct *tty)
|
||||
|
||||
static void moxa_shut_down(struct moxa_port *ch)
|
||||
{
|
||||
struct tty_struct *tp;
|
||||
struct tty_struct *tp = ch->tty;
|
||||
|
||||
if (!(ch->asyncflags & ASYNC_INITIALIZED))
|
||||
return;
|
||||
|
||||
tp = ch->tty;
|
||||
|
||||
MoxaPortDisable(ch);
|
||||
|
||||
/*
|
||||
* If we're a modem control device and HUPCL is on, drop RTS & DTR.
|
||||
*/
|
||||
if (tp->termios->c_cflag & HUPCL)
|
||||
if (C_HUPCL(tp))
|
||||
MoxaPortLineCtrl(ch, 0, 0);
|
||||
|
||||
spin_lock_bh(&moxa_lock);
|
||||
ch->asyncflags &= ~ASYNC_INITIALIZED;
|
||||
spin_unlock_bh(&moxa_lock);
|
||||
}
|
||||
|
||||
/*****************************************************************************
|
||||
@ -2029,7 +2023,9 @@ static int MoxaPortLineStatus(struct moxa_port *port)
|
||||
val &= 0x0B;
|
||||
if (val & 8)
|
||||
val |= 4;
|
||||
spin_lock_bh(&moxa_lock);
|
||||
moxa_new_dcdstate(port, val & 8);
|
||||
spin_unlock_bh(&moxa_lock);
|
||||
val &= 7;
|
||||
return val;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user