OpenE2K
/
linux
6
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

tty: We want the port object to be persistent 

Move the tty_port and uart_info bits around a little. By embedding the uart_info
into the uart_port we get rid of lots of corner case testing and also get the
ability to go port<->state<->info which is a bit more elegant than the current
data structures.

Downsides - we allocate a tiny bit more memory for unused ports, upside we've
removed as much code as it saved for most users..

Signed-off-by: Alan Cox <alan@redhat.com>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Alan Cox 2009-01-02 13:49:21 +00:00 committed by Linus Torvalds
parent 6ef53066ff
commit f751928e0d
3 changed files with 96 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/serial/jsm/jsm_tty.c
View File

@ -272,7 +272,7 @@ static void jsm_tty_close(struct uart_port *port)
jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev, "start\n"); jsm_printk(CLOSE, INFO, &channel->ch_bd->pci_dev, "start\n");
bd = channel->ch_bd; bd = channel->ch_bd;
ts = channel->uart_port.info->port.tty->termios; ts = port->info->port.tty->termios;
channel->ch_flags &= ~(CH_STOPI); channel->ch_flags &= ~(CH_STOPI);

144
drivers/serial/serial_core.c
View File

@ -50,7 +50,7 @@ static struct lock_class_key port_lock_key;
#define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8) #define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8)
#define uart_users(state) ((state)->count + ((state)->info ? (state)->info->port.blocked_open : 0)) #define uart_users(state) ((state)->count + (state)->info.port.blocked_open)
#ifdef CONFIG_SERIAL_CORE_CONSOLE #ifdef CONFIG_SERIAL_CORE_CONSOLE
#define uart_console(port) ((port)->cons && (port)->cons->index == (port)->line) #define uart_console(port) ((port)->cons && (port)->cons->index == (port)->line)
@ -94,7 +94,7 @@ static void __uart_start(struct tty_struct *tty)
struct uart_state *state = tty->driver_data; struct uart_state *state = tty->driver_data;
struct uart_port *port = state->port; struct uart_port *port = state->port;
if (!uart_circ_empty(&state->info->xmit) && state->info->xmit.buf && if (!uart_circ_empty(&state->info.xmit) && state->info.xmit.buf &&
!tty->stopped && !tty->hw_stopped) !tty->stopped && !tty->hw_stopped)
port->ops->start_tx(port); port->ops->start_tx(port);
} }
@ -113,7 +113,7 @@ static void uart_start(struct tty_struct *tty)
static void uart_tasklet_action(unsigned long data) static void uart_tasklet_action(unsigned long data)
{ {
struct uart_state *state = (struct uart_state *)data; struct uart_state *state = (struct uart_state *)data;
tty_wakeup(state->info->port.tty); tty_wakeup(state->info.port.tty);
} }
static inline void static inline void
@ -139,7 +139,7 @@ uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
*/ */
static int uart_startup(struct uart_state *state, int init_hw) static int uart_startup(struct uart_state *state, int init_hw)
{ {
struct uart_info *info = state->info; struct uart_info *info = &state->info;
struct uart_port *port = state->port; struct uart_port *port = state->port;
unsigned long page; unsigned long page;
int retval = 0; int retval = 0;
@ -212,14 +212,15 @@ static int uart_startup(struct uart_state *state, int init_hw)
*/ */
static void uart_shutdown(struct uart_state *state) static void uart_shutdown(struct uart_state *state)
{ {
struct uart_info *info = state->info; struct uart_info *info = &state->info;
struct uart_port *port = state->port; struct uart_port *port = state->port;
struct tty_struct *tty = info->port.tty;
/* /*
* Set the TTY IO error marker * Set the TTY IO error marker
*/ */
if (info->port.tty) if (tty)
set_bit(TTY_IO_ERROR, &info->port.tty->flags); set_bit(TTY_IO_ERROR, &tty->flags);
if (info->flags & UIF_INITIALIZED) { if (info->flags & UIF_INITIALIZED) {
info->flags &= ~UIF_INITIALIZED; info->flags &= ~UIF_INITIALIZED;
@ -227,7 +228,7 @@ static void uart_shutdown(struct uart_state *state)
/* /*
* Turn off DTR and RTS early. * Turn off DTR and RTS early.
*/ */
if (!info->port.tty || (info->port.tty->termios->c_cflag & HUPCL)) if (!tty || (tty->termios->c_cflag & HUPCL))
uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS); uart_clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
/* /*
@ -427,7 +428,7 @@ EXPORT_SYMBOL(uart_get_divisor);
static void static void
uart_change_speed(struct uart_state *state, struct ktermios *old_termios) uart_change_speed(struct uart_state *state, struct ktermios *old_termios)
{ {
struct tty_struct *tty = state->info->port.tty; struct tty_struct *tty = state->info.port.tty;
struct uart_port *port = state->port; struct uart_port *port = state->port;
struct ktermios *termios; struct ktermios *termios;
@ -444,14 +445,14 @@ uart_change_speed(struct uart_state *state, struct ktermios *old_termios)
* Set flags based on termios cflag * Set flags based on termios cflag
*/ */
if (termios->c_cflag & CRTSCTS) if (termios->c_cflag & CRTSCTS)
state->info->flags |= UIF_CTS_FLOW; state->info.flags |= UIF_CTS_FLOW;
else else
state->info->flags &= ~UIF_CTS_FLOW; state->info.flags &= ~UIF_CTS_FLOW;
if (termios->c_cflag & CLOCAL) if (termios->c_cflag & CLOCAL)
state->info->flags &= ~UIF_CHECK_CD; state->info.flags &= ~UIF_CHECK_CD;
else else
state->info->flags |= UIF_CHECK_CD; state->info.flags |= UIF_CHECK_CD;
port->ops->set_termios(port, termios, old_termios); port->ops->set_termios(port, termios, old_termios);
} }
@ -479,7 +480,7 @@ static int uart_put_char(struct tty_struct *tty, unsigned char ch)
{ {
struct uart_state *state = tty->driver_data; struct uart_state *state = tty->driver_data;
return __uart_put_char(state->port, &state->info->xmit, ch); return __uart_put_char(state->port, &state->info.xmit, ch);
} }
static void uart_flush_chars(struct tty_struct *tty) static void uart_flush_chars(struct tty_struct *tty)
@ -500,13 +501,13 @@ uart_write(struct tty_struct *tty, const unsigned char *buf, int count)
* This means you called this function _after_ the port was * This means you called this function _after_ the port was
* closed. No cookie for you. * closed. No cookie for you.
*/ */
if (!state || !state->info) { if (!state) {
WARN_ON(1); WARN_ON(1);
return -EL3HLT; return -EL3HLT;
} }
port = state->port; port = state->port;
circ = &state->info->xmit; circ = &state->info.xmit;
if (!circ->buf) if (!circ->buf)
return 0; return 0;
@ -537,7 +538,7 @@ static int uart_write_room(struct tty_struct *tty)
int ret; int ret;
spin_lock_irqsave(&state->port->lock, flags); spin_lock_irqsave(&state->port->lock, flags);
ret = uart_circ_chars_free(&state->info->xmit); ret = uart_circ_chars_free(&state->info.xmit);
spin_unlock_irqrestore(&state->port->lock, flags); spin_unlock_irqrestore(&state->port->lock, flags);
return ret; return ret;
} }
@ -549,7 +550,7 @@ static int uart_chars_in_buffer(struct tty_struct *tty)
int ret; int ret;
spin_lock_irqsave(&state->port->lock, flags); spin_lock_irqsave(&state->port->lock, flags);
ret = uart_circ_chars_pending(&state->info->xmit); ret = uart_circ_chars_pending(&state->info.xmit);
spin_unlock_irqrestore(&state->port->lock, flags); spin_unlock_irqrestore(&state->port->lock, flags);
return ret; return ret;
} }
@ -564,7 +565,7 @@ static void uart_flush_buffer(struct tty_struct *tty)
* This means you called this function _after_ the port was * This means you called this function _after_ the port was
* closed. No cookie for you. * closed. No cookie for you.
*/ */
if (!state || !state->info) { if (!state) {
WARN_ON(1); WARN_ON(1);
return; return;
} }
@ -573,7 +574,7 @@ static void uart_flush_buffer(struct tty_struct *tty)
pr_debug("uart_flush_buffer(%d) called\n", tty->index); pr_debug("uart_flush_buffer(%d) called\n", tty->index);
spin_lock_irqsave(&port->lock, flags); spin_lock_irqsave(&port->lock, flags);
uart_circ_clear(&state->info->xmit); uart_circ_clear(&state->info.xmit);
if (port->ops->flush_buffer) if (port->ops->flush_buffer)
port->ops->flush_buffer(port); port->ops->flush_buffer(port);
spin_unlock_irqrestore(&port->lock, flags); spin_unlock_irqrestore(&port->lock, flags);
@ -837,15 +838,15 @@ static int uart_set_info(struct uart_state *state,
state->closing_wait = closing_wait; state->closing_wait = closing_wait;
if (new_serial.xmit_fifo_size) if (new_serial.xmit_fifo_size)
port->fifosize = new_serial.xmit_fifo_size; port->fifosize = new_serial.xmit_fifo_size;
if (state->info->port.tty) if (state->info.port.tty)
state->info->port.tty->low_latency = state->info.port.tty->low_latency =
(port->flags & UPF_LOW_LATENCY) ? 1 : 0; (port->flags & UPF_LOW_LATENCY) ? 1 : 0;
check_and_exit: check_and_exit:
retval = 0; retval = 0;
if (port->type == PORT_UNKNOWN) if (port->type == PORT_UNKNOWN)
goto exit; goto exit;
if (state->info->flags & UIF_INITIALIZED) { if (state->info.flags & UIF_INITIALIZED) {
if (((old_flags ^ port->flags) & UPF_SPD_MASK) || if (((old_flags ^ port->flags) & UPF_SPD_MASK) ||
old_custom_divisor != port->custom_divisor) { old_custom_divisor != port->custom_divisor) {
/* /*
@ -858,7 +859,7 @@ static int uart_set_info(struct uart_state *state,
printk(KERN_NOTICE printk(KERN_NOTICE
"%s sets custom speed on %s. This " "%s sets custom speed on %s. This "
"is deprecated.\n", current->comm, "is deprecated.\n", current->comm,
tty_name(state->info->port.tty, buf)); tty_name(state->info.port.tty, buf));
} }
uart_change_speed(state, NULL); uart_change_speed(state, NULL);
} }
@ -889,8 +890,8 @@ static int uart_get_lsr_info(struct uart_state *state,
* interrupt happens). * interrupt happens).
*/ */
if (port->x_char || if (port->x_char ||
((uart_circ_chars_pending(&state->info->xmit) > 0) && ((uart_circ_chars_pending(&state->info.xmit) > 0) &&
!state->info->port.tty->stopped && !state->info->port.tty->hw_stopped)) !state->info.port.tty->stopped && !state->info.port.tty->hw_stopped))
result &= ~TIOCSER_TEMT; result &= ~TIOCSER_TEMT;
return put_user(result, value); return put_user(result, value);
@ -1017,7 +1018,7 @@ uart_wait_modem_status(struct uart_state *state, unsigned long arg)
port->ops->enable_ms(port); port->ops->enable_ms(port);
spin_unlock_irq(&port->lock); spin_unlock_irq(&port->lock);
add_wait_queue(&state->info->delta_msr_wait, &wait); add_wait_queue(&state->info.delta_msr_wait, &wait);
for (;;) { for (;;) {
spin_lock_irq(&port->lock); spin_lock_irq(&port->lock);
memcpy(&cnow, &port->icount, sizeof(struct uart_icount)); memcpy(&cnow, &port->icount, sizeof(struct uart_icount));
@ -1045,7 +1046,7 @@ uart_wait_modem_status(struct uart_state *state, unsigned long arg)
} }
current->state = TASK_RUNNING; current->state = TASK_RUNNING;
remove_wait_queue(&state->info->delta_msr_wait, &wait); remove_wait_queue(&state->info.delta_msr_wait, &wait);
return ret; return ret;
} }
@ -1241,7 +1242,7 @@ static void uart_set_termios(struct tty_struct *tty,
*/ */
if (!(old_termios->c_cflag & CLOCAL) && if (!(old_termios->c_cflag & CLOCAL) &&
(tty->termios->c_cflag & CLOCAL)) (tty->termios->c_cflag & CLOCAL))
wake_up_interruptible(&state->info->port.open_wait); wake_up_interruptible(&info->port.open_wait);
#endif #endif
} }
@ -1303,7 +1304,7 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
* At this point, we stop accepting input. To do this, we * At this point, we stop accepting input. To do this, we
* disable the receive line status interrupts. * disable the receive line status interrupts.
*/ */
if (state->info->flags & UIF_INITIALIZED) { if (state->info.flags & UIF_INITIALIZED) {
unsigned long flags; unsigned long flags;
spin_lock_irqsave(&port->lock, flags); spin_lock_irqsave(&port->lock, flags);
port->ops->stop_rx(port); port->ops->stop_rx(port);
@ -1322,9 +1323,9 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
tty_ldisc_flush(tty); tty_ldisc_flush(tty);
tty->closing = 0; tty->closing = 0;
state->info->port.tty = NULL; state->info.port.tty = NULL;
if (state->info->port.blocked_open) { if (state->info.port.blocked_open) {
if (state->close_delay) if (state->close_delay)
msleep_interruptible(state->close_delay); msleep_interruptible(state->close_delay);
} else if (!uart_console(port)) { } else if (!uart_console(port)) {
@ -1334,8 +1335,8 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
/* /*
* Wake up anyone trying to open this port. * Wake up anyone trying to open this port.
*/ */
state->info->flags &= ~UIF_NORMAL_ACTIVE; state->info.flags &= ~UIF_NORMAL_ACTIVE;
wake_up_interruptible(&state->info->port.open_wait); wake_up_interruptible(&state->info.port.open_wait);
done: done:
mutex_unlock(&state->mutex); mutex_unlock(&state->mutex);
@ -1409,19 +1410,20 @@ static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
static void uart_hangup(struct tty_struct *tty) static void uart_hangup(struct tty_struct *tty)
{ {
struct uart_state *state = tty->driver_data; struct uart_state *state = tty->driver_data;
struct uart_info *info = &state->info;
BUG_ON(!kernel_locked()); BUG_ON(!kernel_locked());
pr_debug("uart_hangup(%d)\n", state->port->line); pr_debug("uart_hangup(%d)\n", state->port->line);
mutex_lock(&state->mutex); mutex_lock(&state->mutex);
if (state->info && state->info->flags & UIF_NORMAL_ACTIVE) { if (info->flags & UIF_NORMAL_ACTIVE) {
uart_flush_buffer(tty); uart_flush_buffer(tty);
uart_shutdown(state); uart_shutdown(state);
state->count = 0; state->count = 0;
state->info->flags &= ~UIF_NORMAL_ACTIVE; info->flags &= ~UIF_NORMAL_ACTIVE;
state->info->port.tty = NULL; info->port.tty = NULL;
wake_up_interruptible(&state->info->port.open_wait); wake_up_interruptible(&info->port.open_wait);
wake_up_interruptible(&state->info->delta_msr_wait); wake_up_interruptible(&info->delta_msr_wait);
} }
mutex_unlock(&state->mutex); mutex_unlock(&state->mutex);
} }
@ -1434,7 +1436,7 @@ static void uart_hangup(struct tty_struct *tty)
*/ */
static void uart_update_termios(struct uart_state *state) static void uart_update_termios(struct uart_state *state)
{ {
struct tty_struct *tty = state->info->port.tty; struct tty_struct *tty = state->info.port.tty;
struct uart_port *port = state->port; struct uart_port *port = state->port;
if (uart_console(port) && port->cons->cflag) { if (uart_console(port) && port->cons->cflag) {
@ -1469,7 +1471,7 @@ static int
uart_block_til_ready(struct file *filp, struct uart_state *state) uart_block_til_ready(struct file *filp, struct uart_state *state)
{ {
DECLARE_WAITQUEUE(wait, current); DECLARE_WAITQUEUE(wait, current);
struct uart_info *info = state->info; struct uart_info *info = &state->info;
struct uart_port *port = state->port; struct uart_port *port = state->port;
unsigned int mctrl; unsigned int mctrl;
@ -1563,28 +1565,6 @@ static struct uart_state *uart_get(struct uart_driver *drv, int line)
ret = -ENXIO; ret = -ENXIO;
goto err_unlock; goto err_unlock;
} }
/* BKL: RACE HERE - LEAK */
/* We should move this into the uart_state structure and kill off
this whole complexity */
if (!state->info) {
state->info = kzalloc(sizeof(struct uart_info), GFP_KERNEL);
if (state->info) {
init_waitqueue_head(&state->info->port.open_wait);
init_waitqueue_head(&state->info->delta_msr_wait);
/*
* Link the info into the other structures.
*/
state->port->info = state->info;
tasklet_init(&state->info->tlet, uart_tasklet_action,
(unsigned long)state);
} else {
ret = -ENOMEM;
goto err_unlock;
}
}
return state; return state;
err_unlock: err_unlock:
@ -1641,9 +1621,10 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
* Any failures from here onwards should not touch the count. * Any failures from here onwards should not touch the count.
*/ */
tty->driver_data = state; tty->driver_data = state;
state->port->info = &state->info;
tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0; tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0;
tty->alt_speed = 0; tty->alt_speed = 0;
state->info->port.tty = tty; state->info.port.tty = tty;
/* /*
* If the port is in the middle of closing, bail out now. * If the port is in the middle of closing, bail out now.
@ -1676,8 +1657,8 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
/* /*
* If this is the first open to succeed, adjust things to suit. * If this is the first open to succeed, adjust things to suit.
*/ */
if (retval == 0 && !(state->info->flags & UIF_NORMAL_ACTIVE)) { if (retval == 0 && !(state->info.flags & UIF_NORMAL_ACTIVE)) {
state->info->flags |= UIF_NORMAL_ACTIVE; state->info.flags |= UIF_NORMAL_ACTIVE;
uart_update_termios(state); uart_update_termios(state);
} }
@ -2028,11 +2009,11 @@ int uart_suspend_port(struct uart_driver *drv, struct uart_port *port)
} }
port->suspended = 1; port->suspended = 1;
if (state->info && state->info->flags & UIF_INITIALIZED) { if (state->info.flags & UIF_INITIALIZED) {
const struct uart_ops *ops = port->ops; const struct uart_ops *ops = port->ops;
int tries; int tries;
state->info->flags = (state->info->flags & ~UIF_INITIALIZED) state->info.flags = (state->info.flags & ~UIF_INITIALIZED)
| UIF_SUSPENDED; | UIF_SUSPENDED;
spin_lock_irq(&port->lock); spin_lock_irq(&port->lock);
@ -2107,15 +2088,15 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
/* /*
* If that's unset, use the tty termios setting. * If that's unset, use the tty termios setting.
*/ */
if (state->info && state->info->port.tty && termios.c_cflag == 0) if (state->info.port.tty && termios.c_cflag == 0)
termios = *state->info->port.tty->termios; termios = *state->info.port.tty->termios;
uart_change_pm(state, 0); uart_change_pm(state, 0);
port->ops->set_termios(port, &termios, NULL); port->ops->set_termios(port, &termios, NULL);
console_start(port->cons); console_start(port->cons);
} }
if (state->info && state->info->flags & UIF_SUSPENDED) { if (state->info.flags & UIF_SUSPENDED) {
const struct uart_ops *ops = port->ops; const struct uart_ops *ops = port->ops;
int ret; int ret;
@ -2130,7 +2111,7 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
ops->set_mctrl(port, port->mctrl); ops->set_mctrl(port, port->mctrl);
ops->start_tx(port); ops->start_tx(port);
spin_unlock_irq(&port->lock); spin_unlock_irq(&port->lock);
state->info->flags |= UIF_INITIALIZED; state->info.flags |= UIF_INITIALIZED;
} else { } else {
/* /*
* Failed to resume - maybe hardware went away? * Failed to resume - maybe hardware went away?
@ -2140,7 +2121,7 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
uart_shutdown(state); uart_shutdown(state);
} }
state->info->flags &= ~UIF_SUSPENDED; state->info.flags &= ~UIF_SUSPENDED;
} }
mutex_unlock(&state->mutex); mutex_unlock(&state->mutex);
@ -2383,8 +2364,12 @@ int uart_register_driver(struct uart_driver *drv)
state->close_delay = 500; /* .5 seconds */ state->close_delay = 500; /* .5 seconds */
state->closing_wait = 30000; /* 30 seconds */ state->closing_wait = 30000; /* 30 seconds */
mutex_init(&state->mutex); mutex_init(&state->mutex);
tty_port_init(&state->info.port);
init_waitqueue_head(&state->info.delta_msr_wait);
tasklet_init(&state->info.tlet, uart_tasklet_action,
(unsigned long)state);
} }
retval = tty_register_driver(normal); retval = tty_register_driver(normal);
@ -2455,7 +2440,7 @@ int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
state->pm_state = -1; state->pm_state = -1;
port->cons = drv->cons; port->cons = drv->cons;
port->info = state->info; port->info = &state->info;
/* /*
* If this port is a console, then the spinlock is already * If this port is a console, then the spinlock is already
@ -2527,17 +2512,10 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
*/ */
tty_unregister_device(drv->tty_driver, port->line); tty_unregister_device(drv->tty_driver, port->line);
info = state->info; info = &state->info;
if (info && info->port.tty) if (info && info->port.tty)
tty_vhangup(info->port.tty); tty_vhangup(info->port.tty);
/*
* All users of this port should now be disconnected from
* this driver, and the port shut down. We should be the
* only thread fiddling with this port from now on.
*/
state->info = NULL;
/* /*
* Free the port IO and memory resources, if any. * Free the port IO and memory resources, if any.
*/ */

62
include/linux/serial_core.h
View File

@ -315,36 +315,14 @@ struct uart_port {
void *private_data; /* generic platform data pointer */ void *private_data; /* generic platform data pointer */
}; };
/*
* This is the state information which is persistent across opens.
* The low level driver must not to touch any elements contained
* within.
*/
struct uart_state {
unsigned int close_delay; /* msec */
unsigned int closing_wait; /* msec */
#define USF_CLOSING_WAIT_INF (0)
#define USF_CLOSING_WAIT_NONE (~0U)
int count;
int pm_state;
struct uart_info *info;
struct uart_port *port;
struct mutex mutex;
};
#define UART_XMIT_SIZE PAGE_SIZE
typedef unsigned int __bitwise__ uif_t;
/* /*
* This is the state information which is only valid when the port * This is the state information which is only valid when the port
* is open; it may be freed by the core driver once the device has * is open; it may be cleared the core driver once the device has
* been closed. Either the low level driver or the core can modify * been closed. Either the low level driver or the core can modify
* stuff here. * stuff here.
*/ */
typedef unsigned int __bitwise__ uif_t;
struct uart_info { struct uart_info {
struct tty_port port; struct tty_port port;
struct circ_buf xmit; struct circ_buf xmit;
@ -366,6 +344,29 @@ struct uart_info {
wait_queue_head_t delta_msr_wait; wait_queue_head_t delta_msr_wait;
}; };
/*
* This is the state information which is persistent across opens.
* The low level driver must not to touch any elements contained
* within.
*/
struct uart_state {
unsigned int close_delay; /* msec */
unsigned int closing_wait; /* msec */
#define USF_CLOSING_WAIT_INF (0)
#define USF_CLOSING_WAIT_NONE (~0U)
int count;
int pm_state;
struct uart_info info;
struct uart_port *port;
struct mutex mutex;
};
#define UART_XMIT_SIZE PAGE_SIZE
/* number of characters left in xmit buffer before we ask for more */ /* number of characters left in xmit buffer before we ask for more */
#define WAKEUP_CHARS 256 #define WAKEUP_CHARS 256
@ -439,8 +440,13 @@ int uart_resume_port(struct uart_driver *reg, struct uart_port *port);
#define uart_circ_chars_free(circ) \ #define uart_circ_chars_free(circ) \
(CIRC_SPACE((circ)->head, (circ)->tail, UART_XMIT_SIZE)) (CIRC_SPACE((circ)->head, (circ)->tail, UART_XMIT_SIZE))
#define uart_tx_stopped(portp) \ static inline int uart_tx_stopped(struct uart_port *port)
((portp)->info->port.tty->stopped || (portp)->info->port.tty->hw_stopped) {
struct tty_struct *tty = port->info->port.tty;
if(tty->stopped || tty->hw_stopped)
return 1;
return 0;
}
/* /*
* The following are helper functions for the low level drivers. * The following are helper functions for the low level drivers.
@ -451,7 +457,7 @@ uart_handle_sysrq_char(struct uart_port *port, unsigned int ch)
#ifdef SUPPORT_SYSRQ #ifdef SUPPORT_SYSRQ
if (port->sysrq) { if (port->sysrq) {
if (ch && time_before(jiffies, port->sysrq)) { if (ch && time_before(jiffies, port->sysrq)) {
handle_sysrq(ch, port->info ? port->info->port.tty : NULL); handle_sysrq(ch, port->info->port.tty);
port->sysrq = 0; port->sysrq = 0;
return 1; return 1;
} }