|
|
@@ -52,7 +52,7 @@ static struct lock_class_key port_lock_key;
|
|
|
|
|
|
#define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8)
|
|
|
|
|
|
-#define uart_users(state) ((state)->count + (state)->info.port.blocked_open)
|
|
|
+#define uart_users(state) ((state)->count + (state)->port.blocked_open)
|
|
|
|
|
|
#ifdef CONFIG_SERIAL_CORE_CONSOLE
|
|
|
#define uart_console(port) ((port)->cons && (port)->cons->index == (port)->line)
|
|
|
@@ -71,19 +71,19 @@ static void uart_change_pm(struct uart_state *state, int pm_state);
|
|
|
*/
|
|
|
void uart_write_wakeup(struct uart_port *port)
|
|
|
{
|
|
|
- struct uart_info *info = port->info;
|
|
|
+ struct uart_state *state = port->state;
|
|
|
/*
|
|
|
* This means you called this function _after_ the port was
|
|
|
* closed. No cookie for you.
|
|
|
*/
|
|
|
- BUG_ON(!info);
|
|
|
- tasklet_schedule(&info->tlet);
|
|
|
+ BUG_ON(!state);
|
|
|
+ tasklet_schedule(&state->tlet);
|
|
|
}
|
|
|
|
|
|
static void uart_stop(struct tty_struct *tty)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
unsigned long flags;
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
@@ -94,9 +94,9 @@ static void uart_stop(struct tty_struct *tty)
|
|
|
static void __uart_start(struct tty_struct *tty)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
|
|
|
- if (!uart_circ_empty(&state->info.xmit) && state->info.xmit.buf &&
|
|
|
+ if (!uart_circ_empty(&state->xmit) && state->xmit.buf &&
|
|
|
!tty->stopped && !tty->hw_stopped)
|
|
|
port->ops->start_tx(port);
|
|
|
}
|
|
|
@@ -104,7 +104,7 @@ static void __uart_start(struct tty_struct *tty)
|
|
|
static void uart_start(struct tty_struct *tty)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
unsigned long flags;
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
@@ -115,7 +115,7 @@ static void uart_start(struct tty_struct *tty)
|
|
|
static void uart_tasklet_action(unsigned long data)
|
|
|
{
|
|
|
struct uart_state *state = (struct uart_state *)data;
|
|
|
- tty_wakeup(state->info.port.tty);
|
|
|
+ tty_wakeup(state->port.tty);
|
|
|
}
|
|
|
|
|
|
static inline void
|
|
|
@@ -141,12 +141,11 @@ uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
|
|
|
*/
|
|
|
static int uart_startup(struct uart_state *state, int init_hw)
|
|
|
{
|
|
|
- struct uart_info *info = &state->info;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
unsigned long page;
|
|
|
int retval = 0;
|
|
|
|
|
|
- if (info->flags & UIF_INITIALIZED)
|
|
|
+ if (state->flags & UIF_INITIALIZED)
|
|
|
return 0;
|
|
|
|
|
|
/*
|
|
|
@@ -154,7 +153,7 @@ static int uart_startup(struct uart_state *state, int init_hw)
|
|
|
* once we have successfully opened the port. Also set
|
|
|
* up the tty->alt_speed kludge
|
|
|
*/
|
|
|
- set_bit(TTY_IO_ERROR, &info->port.tty->flags);
|
|
|
+ set_bit(TTY_IO_ERROR, &state->port.tty->flags);
|
|
|
|
|
|
if (port->type == PORT_UNKNOWN)
|
|
|
return 0;
|
|
|
@@ -163,14 +162,14 @@ static int uart_startup(struct uart_state *state, int init_hw)
|
|
|
* Initialise and allocate the transmit and temporary
|
|
|
* buffer.
|
|
|
*/
|
|
|
- if (!info->xmit.buf) {
|
|
|
+ if (!state->xmit.buf) {
|
|
|
/* This is protected by the per port mutex */
|
|
|
page = get_zeroed_page(GFP_KERNEL);
|
|
|
if (!page)
|
|
|
return -ENOMEM;
|
|
|
|
|
|
- info->xmit.buf = (unsigned char *) page;
|
|
|
- uart_circ_clear(&info->xmit);
|
|
|
+ state->xmit.buf = (unsigned char *) page;
|
|
|
+ uart_circ_clear(&state->xmit);
|
|
|
}
|
|
|
|
|
|
retval = port->ops->startup(port);
|
|
|
@@ -185,20 +184,20 @@ static int uart_startup(struct uart_state *state, int init_hw)
|
|
|
* Setup the RTS and DTR signals once the
|
|
|
* port is open and ready to respond.
|
|
|
*/
|
|
|
- if (info->port.tty->termios->c_cflag & CBAUD)
|
|
|
+ if (state->port.tty->termios->c_cflag & CBAUD)
|
|
|
uart_set_mctrl(port, TIOCM_RTS | TIOCM_DTR);
|
|
|
}
|
|
|
|
|
|
- if (info->flags & UIF_CTS_FLOW) {
|
|
|
+ if (state->flags & UIF_CTS_FLOW) {
|
|
|
spin_lock_irq(&port->lock);
|
|
|
if (!(port->ops->get_mctrl(port) & TIOCM_CTS))
|
|
|
- info->port.tty->hw_stopped = 1;
|
|
|
+ state->port.tty->hw_stopped = 1;
|
|
|
spin_unlock_irq(&port->lock);
|
|
|
}
|
|
|
|
|
|
- info->flags |= UIF_INITIALIZED;
|
|
|
+ state->flags |= UIF_INITIALIZED;
|
|
|
|
|
|
- clear_bit(TTY_IO_ERROR, &info->port.tty->flags);
|
|
|
+ clear_bit(TTY_IO_ERROR, &state->port.tty->flags);
|
|
|
}
|
|
|
|
|
|
if (retval && capable(CAP_SYS_ADMIN))
|
|
|
@@ -214,9 +213,8 @@ static int uart_startup(struct uart_state *state, int init_hw)
|
|
|
*/
|
|
|
static void uart_shutdown(struct uart_state *state)
|
|
|
{
|
|
|
- struct uart_info *info = &state->info;
|
|
|
- struct uart_port *port = state->port;
|
|
|
- struct tty_struct *tty = info->port.tty;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
+ struct tty_struct *tty = state->port.tty;
|
|
|
|
|
|
/*
|
|
|
* Set the TTY IO error marker
|
|
|
@@ -224,8 +222,8 @@ static void uart_shutdown(struct uart_state *state)
|
|
|
if (tty)
|
|
|
set_bit(TTY_IO_ERROR, &tty->flags);
|
|
|
|
|
|
- if (info->flags & UIF_INITIALIZED) {
|
|
|
- info->flags &= ~UIF_INITIALIZED;
|
|
|
+ if (state->flags & UIF_INITIALIZED) {
|
|
|
+ state->flags &= ~UIF_INITIALIZED;
|
|
|
|
|
|
/*
|
|
|
* Turn off DTR and RTS early.
|
|
|
@@ -240,7 +238,7 @@ static void uart_shutdown(struct uart_state *state)
|
|
|
* any outstanding file descriptors should be pointing at
|
|
|
* hung_up_tty_fops now.
|
|
|
*/
|
|
|
- wake_up_interruptible(&info->delta_msr_wait);
|
|
|
+ wake_up_interruptible(&state->delta_msr_wait);
|
|
|
|
|
|
/*
|
|
|
* Free the IRQ and disable the port.
|
|
|
@@ -256,14 +254,14 @@ static void uart_shutdown(struct uart_state *state)
|
|
|
/*
|
|
|
* kill off our tasklet
|
|
|
*/
|
|
|
- tasklet_kill(&info->tlet);
|
|
|
+ tasklet_kill(&state->tlet);
|
|
|
|
|
|
/*
|
|
|
* Free the transmit buffer page.
|
|
|
*/
|
|
|
- if (info->xmit.buf) {
|
|
|
- free_page((unsigned long)info->xmit.buf);
|
|
|
- info->xmit.buf = NULL;
|
|
|
+ if (state->xmit.buf) {
|
|
|
+ free_page((unsigned long)state->xmit.buf);
|
|
|
+ state->xmit.buf = NULL;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -430,8 +428,8 @@ EXPORT_SYMBOL(uart_get_divisor);
|
|
|
static void
|
|
|
uart_change_speed(struct uart_state *state, struct ktermios *old_termios)
|
|
|
{
|
|
|
- struct tty_struct *tty = state->info.port.tty;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct tty_struct *tty = state->port.tty;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
struct ktermios *termios;
|
|
|
|
|
|
/*
|
|
|
@@ -447,14 +445,14 @@ uart_change_speed(struct uart_state *state, struct ktermios *old_termios)
|
|
|
* Set flags based on termios cflag
|
|
|
*/
|
|
|
if (termios->c_cflag & CRTSCTS)
|
|
|
- state->info.flags |= UIF_CTS_FLOW;
|
|
|
+ state->flags |= UIF_CTS_FLOW;
|
|
|
else
|
|
|
- state->info.flags &= ~UIF_CTS_FLOW;
|
|
|
+ state->flags &= ~UIF_CTS_FLOW;
|
|
|
|
|
|
if (termios->c_cflag & CLOCAL)
|
|
|
- state->info.flags &= ~UIF_CHECK_CD;
|
|
|
+ state->flags &= ~UIF_CHECK_CD;
|
|
|
else
|
|
|
- state->info.flags |= UIF_CHECK_CD;
|
|
|
+ state->flags |= UIF_CHECK_CD;
|
|
|
|
|
|
port->ops->set_termios(port, termios, old_termios);
|
|
|
}
|
|
|
@@ -482,7 +480,7 @@ static int uart_put_char(struct tty_struct *tty, unsigned char ch)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
|
|
|
- return __uart_put_char(state->port, &state->info.xmit, ch);
|
|
|
+ return __uart_put_char(state->uart_port, &state->xmit, ch);
|
|
|
}
|
|
|
|
|
|
static void uart_flush_chars(struct tty_struct *tty)
|
|
|
@@ -508,8 +506,8 @@ uart_write(struct tty_struct *tty, const unsigned char *buf, int count)
|
|
|
return -EL3HLT;
|
|
|
}
|
|
|
|
|
|
- port = state->port;
|
|
|
- circ = &state->info.xmit;
|
|
|
+ port = state->uart_port;
|
|
|
+ circ = &state->xmit;
|
|
|
|
|
|
if (!circ->buf)
|
|
|
return 0;
|
|
|
@@ -539,9 +537,9 @@ static int uart_write_room(struct tty_struct *tty)
|
|
|
unsigned long flags;
|
|
|
int ret;
|
|
|
|
|
|
- spin_lock_irqsave(&state->port->lock, flags);
|
|
|
- ret = uart_circ_chars_free(&state->info.xmit);
|
|
|
- spin_unlock_irqrestore(&state->port->lock, flags);
|
|
|
+ spin_lock_irqsave(&state->uart_port->lock, flags);
|
|
|
+ ret = uart_circ_chars_free(&state->xmit);
|
|
|
+ spin_unlock_irqrestore(&state->uart_port->lock, flags);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
@@ -551,9 +549,9 @@ static int uart_chars_in_buffer(struct tty_struct *tty)
|
|
|
unsigned long flags;
|
|
|
int ret;
|
|
|
|
|
|
- spin_lock_irqsave(&state->port->lock, flags);
|
|
|
- ret = uart_circ_chars_pending(&state->info.xmit);
|
|
|
- spin_unlock_irqrestore(&state->port->lock, flags);
|
|
|
+ spin_lock_irqsave(&state->uart_port->lock, flags);
|
|
|
+ ret = uart_circ_chars_pending(&state->xmit);
|
|
|
+ spin_unlock_irqrestore(&state->uart_port->lock, flags);
|
|
|
return ret;
|
|
|
}
|
|
|
|
|
|
@@ -572,11 +570,11 @@ static void uart_flush_buffer(struct tty_struct *tty)
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
- port = state->port;
|
|
|
+ port = state->uart_port;
|
|
|
pr_debug("uart_flush_buffer(%d) called\n", tty->index);
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
- uart_circ_clear(&state->info.xmit);
|
|
|
+ uart_circ_clear(&state->xmit);
|
|
|
if (port->ops->flush_buffer)
|
|
|
port->ops->flush_buffer(port);
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
@@ -590,7 +588,7 @@ static void uart_flush_buffer(struct tty_struct *tty)
|
|
|
static void uart_send_xchar(struct tty_struct *tty, char ch)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
unsigned long flags;
|
|
|
|
|
|
if (port->ops->send_xchar)
|
|
|
@@ -613,13 +611,13 @@ static void uart_throttle(struct tty_struct *tty)
|
|
|
uart_send_xchar(tty, STOP_CHAR(tty));
|
|
|
|
|
|
if (tty->termios->c_cflag & CRTSCTS)
|
|
|
- uart_clear_mctrl(state->port, TIOCM_RTS);
|
|
|
+ uart_clear_mctrl(state->uart_port, TIOCM_RTS);
|
|
|
}
|
|
|
|
|
|
static void uart_unthrottle(struct tty_struct *tty)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
|
|
|
if (I_IXOFF(tty)) {
|
|
|
if (port->x_char)
|
|
|
@@ -635,7 +633,7 @@ static void uart_unthrottle(struct tty_struct *tty)
|
|
|
static int uart_get_info(struct uart_state *state,
|
|
|
struct serial_struct __user *retinfo)
|
|
|
{
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
struct serial_struct tmp;
|
|
|
|
|
|
memset(&tmp, 0, sizeof(tmp));
|
|
|
@@ -674,7 +672,7 @@ static int uart_set_info(struct uart_state *state,
|
|
|
struct serial_struct __user *newinfo)
|
|
|
{
|
|
|
struct serial_struct new_serial;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
unsigned long new_port;
|
|
|
unsigned int change_irq, change_port, closing_wait;
|
|
|
unsigned int old_custom_divisor, close_delay;
|
|
|
@@ -840,15 +838,15 @@ static int uart_set_info(struct uart_state *state,
|
|
|
state->closing_wait = closing_wait;
|
|
|
if (new_serial.xmit_fifo_size)
|
|
|
port->fifosize = new_serial.xmit_fifo_size;
|
|
|
- if (state->info.port.tty)
|
|
|
- state->info.port.tty->low_latency =
|
|
|
+ if (state->port.tty)
|
|
|
+ state->port.tty->low_latency =
|
|
|
(port->flags & UPF_LOW_LATENCY) ? 1 : 0;
|
|
|
|
|
|
check_and_exit:
|
|
|
retval = 0;
|
|
|
if (port->type == PORT_UNKNOWN)
|
|
|
goto exit;
|
|
|
- if (state->info.flags & UIF_INITIALIZED) {
|
|
|
+ if (state->flags & UIF_INITIALIZED) {
|
|
|
if (((old_flags ^ port->flags) & UPF_SPD_MASK) ||
|
|
|
old_custom_divisor != port->custom_divisor) {
|
|
|
/*
|
|
|
@@ -861,7 +859,7 @@ static int uart_set_info(struct uart_state *state,
|
|
|
printk(KERN_NOTICE
|
|
|
"%s sets custom speed on %s. This "
|
|
|
"is deprecated.\n", current->comm,
|
|
|
- tty_name(state->info.port.tty, buf));
|
|
|
+ tty_name(state->port.tty, buf));
|
|
|
}
|
|
|
uart_change_speed(state, NULL);
|
|
|
}
|
|
|
@@ -880,7 +878,7 @@ static int uart_set_info(struct uart_state *state,
|
|
|
static int uart_get_lsr_info(struct uart_state *state,
|
|
|
unsigned int __user *value)
|
|
|
{
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
unsigned int result;
|
|
|
|
|
|
result = port->ops->tx_empty(port);
|
|
|
@@ -892,8 +890,8 @@ static int uart_get_lsr_info(struct uart_state *state,
|
|
|
* interrupt happens).
|
|
|
*/
|
|
|
if (port->x_char ||
|
|
|
- ((uart_circ_chars_pending(&state->info.xmit) > 0) &&
|
|
|
- !state->info.port.tty->stopped && !state->info.port.tty->hw_stopped))
|
|
|
+ ((uart_circ_chars_pending(&state->xmit) > 0) &&
|
|
|
+ !state->port.tty->stopped && !state->port.tty->hw_stopped))
|
|
|
result &= ~TIOCSER_TEMT;
|
|
|
|
|
|
return put_user(result, value);
|
|
|
@@ -902,7 +900,7 @@ static int uart_get_lsr_info(struct uart_state *state,
|
|
|
static int uart_tiocmget(struct tty_struct *tty, struct file *file)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
int result = -EIO;
|
|
|
|
|
|
mutex_lock(&state->mutex);
|
|
|
@@ -924,7 +922,7 @@ uart_tiocmset(struct tty_struct *tty, struct file *file,
|
|
|
unsigned int set, unsigned int clear)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
int ret = -EIO;
|
|
|
|
|
|
mutex_lock(&state->mutex);
|
|
|
@@ -940,7 +938,7 @@ uart_tiocmset(struct tty_struct *tty, struct file *file,
|
|
|
static int uart_break_ctl(struct tty_struct *tty, int break_state)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
|
|
|
mutex_lock(&state->mutex);
|
|
|
|
|
|
@@ -953,7 +951,7 @@ static int uart_break_ctl(struct tty_struct *tty, int break_state)
|
|
|
|
|
|
static int uart_do_autoconfig(struct uart_state *state)
|
|
|
{
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
int flags, ret;
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
@@ -1003,7 +1001,7 @@ static int uart_do_autoconfig(struct uart_state *state)
|
|
|
static int
|
|
|
uart_wait_modem_status(struct uart_state *state, unsigned long arg)
|
|
|
{
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
struct uart_icount cprev, cnow;
|
|
|
int ret;
|
|
|
@@ -1020,7 +1018,7 @@ uart_wait_modem_status(struct uart_state *state, unsigned long arg)
|
|
|
port->ops->enable_ms(port);
|
|
|
spin_unlock_irq(&port->lock);
|
|
|
|
|
|
- add_wait_queue(&state->info.delta_msr_wait, &wait);
|
|
|
+ add_wait_queue(&state->delta_msr_wait, &wait);
|
|
|
for (;;) {
|
|
|
spin_lock_irq(&port->lock);
|
|
|
memcpy(&cnow, &port->icount, sizeof(struct uart_icount));
|
|
|
@@ -1048,7 +1046,7 @@ uart_wait_modem_status(struct uart_state *state, unsigned long arg)
|
|
|
}
|
|
|
|
|
|
current->state = TASK_RUNNING;
|
|
|
- remove_wait_queue(&state->info.delta_msr_wait, &wait);
|
|
|
+ remove_wait_queue(&state->delta_msr_wait, &wait);
|
|
|
|
|
|
return ret;
|
|
|
}
|
|
|
@@ -1064,7 +1062,7 @@ static int uart_get_count(struct uart_state *state,
|
|
|
{
|
|
|
struct serial_icounter_struct icount;
|
|
|
struct uart_icount cnow;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
|
|
|
spin_lock_irq(&port->lock);
|
|
|
memcpy(&cnow, &port->icount, sizeof(struct uart_icount));
|
|
|
@@ -1160,7 +1158,7 @@ uart_ioctl(struct tty_struct *tty, struct file *filp, unsigned int cmd,
|
|
|
break;
|
|
|
|
|
|
default: {
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
if (port->ops->ioctl)
|
|
|
ret = port->ops->ioctl(port, cmd, arg);
|
|
|
break;
|
|
|
@@ -1175,7 +1173,7 @@ out:
|
|
|
static void uart_set_ldisc(struct tty_struct *tty)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
|
|
|
if (port->ops->set_ldisc)
|
|
|
port->ops->set_ldisc(port);
|
|
|
@@ -1207,7 +1205,7 @@ static void uart_set_termios(struct tty_struct *tty,
|
|
|
|
|
|
/* Handle transition to B0 status */
|
|
|
if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
|
|
|
- uart_clear_mctrl(state->port, TIOCM_RTS | TIOCM_DTR);
|
|
|
+ uart_clear_mctrl(state->uart_port, TIOCM_RTS | TIOCM_DTR);
|
|
|
|
|
|
/* Handle transition away from B0 status */
|
|
|
if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
|
|
|
@@ -1215,25 +1213,25 @@ static void uart_set_termios(struct tty_struct *tty,
|
|
|
if (!(cflag & CRTSCTS) ||
|
|
|
!test_bit(TTY_THROTTLED, &tty->flags))
|
|
|
mask |= TIOCM_RTS;
|
|
|
- uart_set_mctrl(state->port, mask);
|
|
|
+ uart_set_mctrl(state->uart_port, mask);
|
|
|
}
|
|
|
|
|
|
/* Handle turning off CRTSCTS */
|
|
|
if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
|
|
|
- spin_lock_irqsave(&state->port->lock, flags);
|
|
|
+ spin_lock_irqsave(&state->uart_port->lock, flags);
|
|
|
tty->hw_stopped = 0;
|
|
|
__uart_start(tty);
|
|
|
- spin_unlock_irqrestore(&state->port->lock, flags);
|
|
|
+ spin_unlock_irqrestore(&state->uart_port->lock, flags);
|
|
|
}
|
|
|
|
|
|
/* Handle turning on CRTSCTS */
|
|
|
if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
|
|
|
- spin_lock_irqsave(&state->port->lock, flags);
|
|
|
- if (!(state->port->ops->get_mctrl(state->port) & TIOCM_CTS)) {
|
|
|
+ spin_lock_irqsave(&state->uart_port->lock, flags);
|
|
|
+ if (!(state->uart_port->ops->get_mctrl(state->uart_port) & TIOCM_CTS)) {
|
|
|
tty->hw_stopped = 1;
|
|
|
- state->port->ops->stop_tx(state->port);
|
|
|
+ state->uart_port->ops->stop_tx(state->uart_port);
|
|
|
}
|
|
|
- spin_unlock_irqrestore(&state->port->lock, flags);
|
|
|
+ spin_unlock_irqrestore(&state->uart_port->lock, flags);
|
|
|
}
|
|
|
#if 0
|
|
|
/*
|
|
|
@@ -1244,7 +1242,7 @@ static void uart_set_termios(struct tty_struct *tty,
|
|
|
*/
|
|
|
if (!(old_termios->c_cflag & CLOCAL) &&
|
|
|
(tty->termios->c_cflag & CLOCAL))
|
|
|
- wake_up_interruptible(&info->port.open_wait);
|
|
|
+ wake_up_interruptible(&state->uart_port.open_wait);
|
|
|
#endif
|
|
|
}
|
|
|
|
|
|
@@ -1260,10 +1258,10 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
|
|
|
|
|
|
BUG_ON(!kernel_locked());
|
|
|
|
|
|
- if (!state || !state->port)
|
|
|
+ if (!state || !state->uart_port)
|
|
|
return;
|
|
|
|
|
|
- port = state->port;
|
|
|
+ port = state->uart_port;
|
|
|
|
|
|
pr_debug("uart_close(%d) called\n", port->line);
|
|
|
|
|
|
@@ -1306,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
|
|
|
* disable the receive line status interrupts.
|
|
|
*/
|
|
|
- if (state->info.flags & UIF_INITIALIZED) {
|
|
|
+ if (state->flags & UIF_INITIALIZED) {
|
|
|
unsigned long flags;
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
port->ops->stop_rx(port);
|
|
|
@@ -1325,9 +1323,9 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
|
|
|
tty_ldisc_flush(tty);
|
|
|
|
|
|
tty->closing = 0;
|
|
|
- state->info.port.tty = NULL;
|
|
|
+ state->port.tty = NULL;
|
|
|
|
|
|
- if (state->info.port.blocked_open) {
|
|
|
+ if (state->port.blocked_open) {
|
|
|
if (state->close_delay)
|
|
|
msleep_interruptible(state->close_delay);
|
|
|
} else if (!uart_console(port)) {
|
|
|
@@ -1337,8 +1335,8 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
|
|
|
/*
|
|
|
* Wake up anyone trying to open this port.
|
|
|
*/
|
|
|
- state->info.flags &= ~UIF_NORMAL_ACTIVE;
|
|
|
- wake_up_interruptible(&state->info.port.open_wait);
|
|
|
+ state->flags &= ~UIF_NORMAL_ACTIVE;
|
|
|
+ wake_up_interruptible(&state->port.open_wait);
|
|
|
|
|
|
done:
|
|
|
mutex_unlock(&state->mutex);
|
|
|
@@ -1347,7 +1345,7 @@ static void uart_close(struct tty_struct *tty, struct file *filp)
|
|
|
static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
unsigned long char_time, expire;
|
|
|
|
|
|
if (port->type == PORT_UNKNOWN || port->fifosize == 0)
|
|
|
@@ -1412,20 +1410,19 @@ static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
|
|
|
static void uart_hangup(struct tty_struct *tty)
|
|
|
{
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
- struct uart_info *info = &state->info;
|
|
|
|
|
|
BUG_ON(!kernel_locked());
|
|
|
- pr_debug("uart_hangup(%d)\n", state->port->line);
|
|
|
+ pr_debug("uart_hangup(%d)\n", state->uart_port->line);
|
|
|
|
|
|
mutex_lock(&state->mutex);
|
|
|
- if (info->flags & UIF_NORMAL_ACTIVE) {
|
|
|
+ if (state->flags & UIF_NORMAL_ACTIVE) {
|
|
|
uart_flush_buffer(tty);
|
|
|
uart_shutdown(state);
|
|
|
state->count = 0;
|
|
|
- info->flags &= ~UIF_NORMAL_ACTIVE;
|
|
|
- info->port.tty = NULL;
|
|
|
- wake_up_interruptible(&info->port.open_wait);
|
|
|
- wake_up_interruptible(&info->delta_msr_wait);
|
|
|
+ state->flags &= ~UIF_NORMAL_ACTIVE;
|
|
|
+ state->port.tty = NULL;
|
|
|
+ wake_up_interruptible(&state->port.open_wait);
|
|
|
+ wake_up_interruptible(&state->delta_msr_wait);
|
|
|
}
|
|
|
mutex_unlock(&state->mutex);
|
|
|
}
|
|
|
@@ -1438,8 +1435,8 @@ static void uart_hangup(struct tty_struct *tty)
|
|
|
*/
|
|
|
static void uart_update_termios(struct uart_state *state)
|
|
|
{
|
|
|
- struct tty_struct *tty = state->info.port.tty;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct tty_struct *tty = state->port.tty;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
|
|
|
if (uart_console(port) && port->cons->cflag) {
|
|
|
tty->termios->c_cflag = port->cons->cflag;
|
|
|
@@ -1473,27 +1470,26 @@ static int
|
|
|
uart_block_til_ready(struct file *filp, struct uart_state *state)
|
|
|
{
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
- struct uart_info *info = &state->info;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
unsigned int mctrl;
|
|
|
|
|
|
- info->port.blocked_open++;
|
|
|
+ state->port.blocked_open++;
|
|
|
state->count--;
|
|
|
|
|
|
- add_wait_queue(&info->port.open_wait, &wait);
|
|
|
+ add_wait_queue(&state->port.open_wait, &wait);
|
|
|
while (1) {
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
|
|
/*
|
|
|
* If we have been hung up, tell userspace/restart open.
|
|
|
*/
|
|
|
- if (tty_hung_up_p(filp) || info->port.tty == NULL)
|
|
|
+ if (tty_hung_up_p(filp) || state->port.tty == NULL)
|
|
|
break;
|
|
|
|
|
|
/*
|
|
|
* If the port has been closed, tell userspace/restart open.
|
|
|
*/
|
|
|
- if (!(info->flags & UIF_INITIALIZED))
|
|
|
+ if (!(state->flags & UIF_INITIALIZED))
|
|
|
break;
|
|
|
|
|
|
/*
|
|
|
@@ -1506,8 +1502,8 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
|
|
|
* have set TTY_IO_ERROR for a non-existant port.
|
|
|
*/
|
|
|
if ((filp->f_flags & O_NONBLOCK) ||
|
|
|
- (info->port.tty->termios->c_cflag & CLOCAL) ||
|
|
|
- (info->port.tty->flags & (1 << TTY_IO_ERROR)))
|
|
|
+ (state->port.tty->termios->c_cflag & CLOCAL) ||
|
|
|
+ (state->port.tty->flags & (1 << TTY_IO_ERROR)))
|
|
|
break;
|
|
|
|
|
|
/*
|
|
|
@@ -1515,7 +1511,7 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
|
|
|
* not set RTS here - we want to make sure we catch
|
|
|
* the data from the modem.
|
|
|
*/
|
|
|
- if (info->port.tty->termios->c_cflag & CBAUD)
|
|
|
+ if (state->port.tty->termios->c_cflag & CBAUD)
|
|
|
uart_set_mctrl(port, TIOCM_DTR);
|
|
|
|
|
|
/*
|
|
|
@@ -1537,15 +1533,15 @@ uart_block_til_ready(struct file *filp, struct uart_state *state)
|
|
|
break;
|
|
|
}
|
|
|
set_current_state(TASK_RUNNING);
|
|
|
- remove_wait_queue(&info->port.open_wait, &wait);
|
|
|
+ remove_wait_queue(&state->port.open_wait, &wait);
|
|
|
|
|
|
state->count++;
|
|
|
- info->port.blocked_open--;
|
|
|
+ state->port.blocked_open--;
|
|
|
|
|
|
if (signal_pending(current))
|
|
|
return -ERESTARTSYS;
|
|
|
|
|
|
- if (!info->port.tty || tty_hung_up_p(filp))
|
|
|
+ if (!state->port.tty || tty_hung_up_p(filp))
|
|
|
return -EAGAIN;
|
|
|
|
|
|
return 0;
|
|
|
@@ -1563,7 +1559,7 @@ static struct uart_state *uart_get(struct uart_driver *drv, int line)
|
|
|
}
|
|
|
|
|
|
state->count++;
|
|
|
- if (!state->port || state->port->flags & UPF_DEAD) {
|
|
|
+ if (!state->uart_port || state->uart_port->flags & UPF_DEAD) {
|
|
|
ret = -ENXIO;
|
|
|
goto err_unlock;
|
|
|
}
|
|
|
@@ -1606,10 +1602,11 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
|
|
|
|
|
|
/*
|
|
|
* We take the semaphore inside uart_get to guarantee that we won't
|
|
|
- * be re-entered while allocating the info structure, or while we
|
|
|
+ * be re-entered while allocating the state structure, or while we
|
|
|
* request any IRQs that the driver may need. This also has the nice
|
|
|
* side-effect that it delays the action of uart_hangup, so we can
|
|
|
- * guarantee that info->port.tty will always contain something reasonable.
|
|
|
+ * guarantee that state->port.tty will always contain something
|
|
|
+ * reasonable.
|
|
|
*/
|
|
|
state = uart_get(drv, line);
|
|
|
if (IS_ERR(state)) {
|
|
|
@@ -1623,10 +1620,10 @@ static int uart_open(struct tty_struct *tty, struct file *filp)
|
|
|
* Any failures from here onwards should not touch the count.
|
|
|
*/
|
|
|
tty->driver_data = state;
|
|
|
- state->port->info = &state->info;
|
|
|
- tty->low_latency = (state->port->flags & UPF_LOW_LATENCY) ? 1 : 0;
|
|
|
+ state->uart_port->state = state;
|
|
|
+ tty->low_latency = (state->uart_port->flags & UPF_LOW_LATENCY) ? 1 : 0;
|
|
|
tty->alt_speed = 0;
|
|
|
- state->info.port.tty = tty;
|
|
|
+ state->port.tty = tty;
|
|
|
|
|
|
/*
|
|
|
* If the port is in the middle of closing, bail out now.
|
|
|
@@ -1659,8 +1656,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 (retval == 0 && !(state->info.flags & UIF_NORMAL_ACTIVE)) {
|
|
|
- state->info.flags |= UIF_NORMAL_ACTIVE;
|
|
|
+ if (retval == 0 && !(state->flags & UIF_NORMAL_ACTIVE)) {
|
|
|
+ state->flags |= UIF_NORMAL_ACTIVE;
|
|
|
|
|
|
uart_update_termios(state);
|
|
|
}
|
|
|
@@ -1688,7 +1685,7 @@ static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i)
|
|
|
{
|
|
|
struct uart_state *state = drv->state + i;
|
|
|
int pm_state;
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
char stat_buf[32];
|
|
|
unsigned int status;
|
|
|
int mmio;
|
|
|
@@ -1958,7 +1955,7 @@ EXPORT_SYMBOL_GPL(uart_set_options);
|
|
|
|
|
|
static void uart_change_pm(struct uart_state *state, int pm_state)
|
|
|
{
|
|
|
- struct uart_port *port = state->port;
|
|
|
+ struct uart_port *port = state->uart_port;
|
|
|
|
|
|
if (state->pm_state != pm_state) {
|
|
|
if (port->ops->pm)
|
|
|
@@ -2005,11 +2002,11 @@ int uart_suspend_port(struct uart_driver *drv, struct uart_port *port)
|
|
|
}
|
|
|
port->suspended = 1;
|
|
|
|
|
|
- if (state->info.flags & UIF_INITIALIZED) {
|
|
|
+ if (state->flags & UIF_INITIALIZED) {
|
|
|
const struct uart_ops *ops = port->ops;
|
|
|
int tries;
|
|
|
|
|
|
- state->info.flags = (state->info.flags & ~UIF_INITIALIZED)
|
|
|
+ state->flags = (state->flags & ~UIF_INITIALIZED)
|
|
|
| UIF_SUSPENDED;
|
|
|
|
|
|
spin_lock_irq(&port->lock);
|
|
|
@@ -2084,15 +2081,15 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
|
|
|
/*
|
|
|
* If that's unset, use the tty termios setting.
|
|
|
*/
|
|
|
- if (state->info.port.tty && termios.c_cflag == 0)
|
|
|
- termios = *state->info.port.tty->termios;
|
|
|
+ if (state->port.tty && termios.c_cflag == 0)
|
|
|
+ termios = *state->port.tty->termios;
|
|
|
|
|
|
uart_change_pm(state, 0);
|
|
|
port->ops->set_termios(port, &termios, NULL);
|
|
|
console_start(port->cons);
|
|
|
}
|
|
|
|
|
|
- if (state->info.flags & UIF_SUSPENDED) {
|
|
|
+ if (state->flags & UIF_SUSPENDED) {
|
|
|
const struct uart_ops *ops = port->ops;
|
|
|
int ret;
|
|
|
|
|
|
@@ -2107,7 +2104,7 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
|
|
|
ops->set_mctrl(port, port->mctrl);
|
|
|
ops->start_tx(port);
|
|
|
spin_unlock_irq(&port->lock);
|
|
|
- state->info.flags |= UIF_INITIALIZED;
|
|
|
+ state->flags |= UIF_INITIALIZED;
|
|
|
} else {
|
|
|
/*
|
|
|
* Failed to resume - maybe hardware went away?
|
|
|
@@ -2117,7 +2114,7 @@ int uart_resume_port(struct uart_driver *drv, struct uart_port *port)
|
|
|
uart_shutdown(state);
|
|
|
}
|
|
|
|
|
|
- state->info.flags &= ~UIF_SUSPENDED;
|
|
|
+ state->flags &= ~UIF_SUSPENDED;
|
|
|
}
|
|
|
|
|
|
mutex_unlock(&state->mutex);
|
|
|
@@ -2232,10 +2229,10 @@ static int uart_poll_init(struct tty_driver *driver, int line, char *options)
|
|
|
int parity = 'n';
|
|
|
int flow = 'n';
|
|
|
|
|
|
- if (!state || !state->port)
|
|
|
+ if (!state || !state->uart_port)
|
|
|
return -1;
|
|
|
|
|
|
- port = state->port;
|
|
|
+ port = state->uart_port;
|
|
|
if (!(port->ops->poll_get_char && port->ops->poll_put_char))
|
|
|
return -1;
|
|
|
|
|
|
@@ -2253,10 +2250,10 @@ static int uart_poll_get_char(struct tty_driver *driver, int line)
|
|
|
struct uart_state *state = drv->state + line;
|
|
|
struct uart_port *port;
|
|
|
|
|
|
- if (!state || !state->port)
|
|
|
+ if (!state || !state->uart_port)
|
|
|
return -1;
|
|
|
|
|
|
- port = state->port;
|
|
|
+ port = state->uart_port;
|
|
|
return port->ops->poll_get_char(port);
|
|
|
}
|
|
|
|
|
|
@@ -2266,10 +2263,10 @@ static void uart_poll_put_char(struct tty_driver *driver, int line, char ch)
|
|
|
struct uart_state *state = drv->state + line;
|
|
|
struct uart_port *port;
|
|
|
|
|
|
- if (!state || !state->port)
|
|
|
+ if (!state || !state->uart_port)
|
|
|
return;
|
|
|
|
|
|
- port = state->port;
|
|
|
+ port = state->uart_port;
|
|
|
port->ops->poll_put_char(port, ch);
|
|
|
}
|
|
|
#endif
|
|
|
@@ -2365,9 +2362,9 @@ int uart_register_driver(struct uart_driver *drv)
|
|
|
state->closing_wait = 30000; /* 30 seconds */
|
|
|
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,
|
|
|
+ tty_port_init(&state->port);
|
|
|
+ init_waitqueue_head(&state->delta_msr_wait);
|
|
|
+ tasklet_init(&state->tlet, uart_tasklet_action,
|
|
|
(unsigned long)state);
|
|
|
}
|
|
|
|
|
|
@@ -2430,16 +2427,16 @@ int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
|
|
|
|
|
|
mutex_lock(&port_mutex);
|
|
|
mutex_lock(&state->mutex);
|
|
|
- if (state->port) {
|
|
|
+ if (state->uart_port) {
|
|
|
ret = -EINVAL;
|
|
|
goto out;
|
|
|
}
|
|
|
|
|
|
- state->port = port;
|
|
|
+ state->uart_port = port;
|
|
|
state->pm_state = -1;
|
|
|
|
|
|
port->cons = drv->cons;
|
|
|
- port->info = &state->info;
|
|
|
+ port->state = state;
|
|
|
|
|
|
/*
|
|
|
* If this port is a console, then the spinlock is already
|
|
|
@@ -2488,13 +2485,12 @@ int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
|
|
|
int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
|
|
|
{
|
|
|
struct uart_state *state = drv->state + port->line;
|
|
|
- struct uart_info *info;
|
|
|
|
|
|
BUG_ON(in_interrupt());
|
|
|
|
|
|
- if (state->port != port)
|
|
|
+ if (state->uart_port != port)
|
|
|
printk(KERN_ALERT "Removing wrong port: %p != %p\n",
|
|
|
- state->port, port);
|
|
|
+ state->uart_port, port);
|
|
|
|
|
|
mutex_lock(&port_mutex);
|
|
|
|
|
|
@@ -2511,9 +2507,8 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
|
|
|
*/
|
|
|
tty_unregister_device(drv->tty_driver, port->line);
|
|
|
|
|
|
- info = &state->info;
|
|
|
- if (info && info->port.tty)
|
|
|
- tty_vhangup(info->port.tty);
|
|
|
+ if (state->port.tty)
|
|
|
+ tty_vhangup(state->port.tty);
|
|
|
|
|
|
/*
|
|
|
* Free the port IO and memory resources, if any.
|
|
|
@@ -2529,10 +2524,9 @@ int uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
|
|
|
/*
|
|
|
* Kill the tasklet, and free resources.
|
|
|
*/
|
|
|
- if (info)
|
|
|
- tasklet_kill(&info->tlet);
|
|
|
+ tasklet_kill(&state->tlet);
|
|
|
|
|
|
- state->port = NULL;
|
|
|
+ state->uart_port = NULL;
|
|
|
mutex_unlock(&port_mutex);
|
|
|
|
|
|
return 0;
|
Alan Cox