Commit a8f5cda0 authored by Jiri Slaby's avatar Jiri Slaby Committed by Linus Torvalds
Browse files

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: default avatarJiri Slaby <jirislaby@gmail.com>
Tested-by: default avatarOyvind Aabling <Oyvind.Aabling@uni-c.dk>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 2a541341

drivers/char/moxa.c

+158 −162
Original line number Diff line number Diff line
@@ -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);



	moxa_unthrottle(tty);

	mutex_unlock(&moxa_openlock);



	if (ch->type == PORT_16550A) {

		MoxaSetFifo(ch, 1);

	} else {

		MoxaSetFifo(ch, 0);

	}

	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);



	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) {

		return;

	}

	if (tty->driver_data == NULL) {

	if (port == MAX_PORTS || tty_hung_up_p(filp))

		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;

}

CRA Git | Maintained and supported by SUSTech CRA and CCSE