2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Driver core for serial ports
|
|
|
|
*
|
|
|
|
* Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
|
|
|
|
*
|
|
|
|
* Copyright 1999 ARM Limited
|
|
|
|
* Copyright (C) 2000-2001 Deep Blue Solutions Ltd.
|
|
|
|
*
|
|
|
|
* 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/module.h>
|
|
|
|
#include <linux/tty.h>
|
2011-11-10 04:33:43 +08:00
|
|
|
#include <linux/tty_flip.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/console.h>
|
2014-03-28 09:29:46 +08:00
|
|
|
#include <linux/of.h>
|
2009-04-01 06:19:21 +08:00
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/device.h>
|
|
|
|
#include <linux/serial.h> /* for serial_state and serial_icounter_struct */
|
2009-09-20 04:13:30 +08:00
|
|
|
#include <linux/serial_core.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/delay.h>
|
2006-01-13 02:44:32 +08:00
|
|
|
#include <linux/mutex.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#include <asm/irq.h>
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This is used to lock changes in serial line configuration.
|
|
|
|
*/
|
2006-01-13 02:44:32 +08:00
|
|
|
static DEFINE_MUTEX(port_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-07-03 15:25:03 +08:00
|
|
|
/*
|
|
|
|
* lockdep: port->lock is initialized in two places, but we
|
|
|
|
* want only one lock-class:
|
|
|
|
*/
|
|
|
|
static struct lock_class_key port_lock_key;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
#define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8)
|
|
|
|
|
2010-06-02 04:52:51 +08:00
|
|
|
static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
|
2008-02-08 20:18:53 +08:00
|
|
|
struct ktermios *old_termios);
|
2011-07-14 20:35:10 +08:00
|
|
|
static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
|
2012-12-07 18:36:08 +08:00
|
|
|
static void uart_change_pm(struct uart_state *state,
|
|
|
|
enum uart_pm_state pm_state);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-11-10 04:33:51 +08:00
|
|
|
static void uart_port_shutdown(struct tty_port *port);
|
|
|
|
|
2014-09-11 03:06:24 +08:00
|
|
|
static int uart_dcd_enabled(struct uart_port *uport)
|
|
|
|
{
|
2014-10-17 02:19:47 +08:00
|
|
|
return !!(uport->status & UPSTAT_DCD_ENABLE);
|
2014-09-11 03:06:24 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* This routine is used by the interrupt handler to schedule processing in
|
|
|
|
* the software interrupt portion of the driver.
|
|
|
|
*/
|
|
|
|
void uart_write_wakeup(struct uart_port *port)
|
|
|
|
{
|
2009-09-20 04:13:28 +08:00
|
|
|
struct uart_state *state = port->state;
|
2006-03-08 13:55:20 +08:00
|
|
|
/*
|
|
|
|
* This means you called this function _after_ the port was
|
|
|
|
* closed. No cookie for you.
|
|
|
|
*/
|
2009-09-20 04:13:28 +08:00
|
|
|
BUG_ON(!state);
|
2011-07-14 20:35:12 +08:00
|
|
|
tty_wakeup(state->port.tty);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void uart_stop(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:28 +08:00
|
|
|
struct uart_port *port = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
2005-08-31 17:12:14 +08:00
|
|
|
port->ops->stop_tx(port);
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __uart_start(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:28 +08:00
|
|
|
struct uart_port *port = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-09-11 03:06:26 +08:00
|
|
|
if (!uart_tx_stopped(port))
|
2005-08-31 17:12:14 +08:00
|
|
|
port->ops->start_tx(port);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void uart_start(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:28 +08:00
|
|
|
struct uart_port *port = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
|
__uart_start(tty);
|
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
unsigned int old;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
|
old = port->mctrl;
|
|
|
|
port->mctrl = (old & ~clear) | set;
|
|
|
|
if (old != port->mctrl)
|
|
|
|
port->ops->set_mctrl(port, port->mctrl);
|
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
|
}
|
|
|
|
|
2008-02-08 20:18:53 +08:00
|
|
|
#define uart_set_mctrl(port, set) uart_update_mctrl(port, set, 0)
|
|
|
|
#define uart_clear_mctrl(port, clear) uart_update_mctrl(port, 0, clear)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Startup the port. This will be called once per open. All calls
|
2008-07-17 04:53:50 +08:00
|
|
|
* will be serialised by the per-port mutex.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2011-11-10 04:34:14 +08:00
|
|
|
static int uart_port_startup(struct tty_struct *tty, struct uart_state *state,
|
|
|
|
int init_hw)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-20 04:13:29 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long page;
|
|
|
|
int retval = 0;
|
|
|
|
|
2009-09-20 04:13:29 +08:00
|
|
|
if (uport->type == PORT_UNKNOWN)
|
2011-11-10 04:34:14 +08:00
|
|
|
return 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-04-23 18:33:22 +08:00
|
|
|
/*
|
|
|
|
* Make sure the device is in D0 state.
|
|
|
|
*/
|
|
|
|
uart_change_pm(state, UART_PM_STATE_ON);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Initialise and allocate the transmit and temporary
|
|
|
|
* buffer.
|
|
|
|
*/
|
2009-09-20 04:13:28 +08:00
|
|
|
if (!state->xmit.buf) {
|
2008-07-17 04:53:50 +08:00
|
|
|
/* This is protected by the per port mutex */
|
2005-04-17 06:20:36 +08:00
|
|
|
page = get_zeroed_page(GFP_KERNEL);
|
|
|
|
if (!page)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
state->xmit.buf = (unsigned char *) page;
|
|
|
|
uart_circ_clear(&state->xmit);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-09-20 04:13:29 +08:00
|
|
|
retval = uport->ops->startup(uport);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (retval == 0) {
|
2011-03-30 06:10:55 +08:00
|
|
|
if (uart_console(uport) && uport->cons->cflag) {
|
2012-07-14 22:31:47 +08:00
|
|
|
tty->termios.c_cflag = uport->cons->cflag;
|
2011-03-30 06:10:55 +08:00
|
|
|
uport->cons->cflag = 0;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Initialise the hardware port settings.
|
|
|
|
*/
|
|
|
|
uart_change_speed(tty, state, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-03-30 06:10:55 +08:00
|
|
|
if (init_hw) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Setup the RTS and DTR signals once the
|
|
|
|
* port is open and ready to respond.
|
|
|
|
*/
|
2012-07-14 22:31:47 +08:00
|
|
|
if (tty->termios.c_cflag & CBAUD)
|
2009-09-20 04:13:29 +08:00
|
|
|
uart_set_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2014-09-03 05:39:10 +08:00
|
|
|
|
2014-09-11 03:06:24 +08:00
|
|
|
spin_lock_irq(&uport->lock);
|
2014-09-11 03:06:26 +08:00
|
|
|
if (uart_cts_enabled(uport) &&
|
|
|
|
!(uport->ops->get_mctrl(uport) & TIOCM_CTS))
|
|
|
|
uport->hw_stopped = 1;
|
|
|
|
else
|
|
|
|
uport->hw_stopped = 0;
|
2014-09-11 03:06:24 +08:00
|
|
|
spin_unlock_irq(&uport->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2011-08-17 19:48:15 +08:00
|
|
|
/*
|
|
|
|
* This is to allow setserial on this port. People may want to set
|
|
|
|
* port/irq/type and then reconfigure the port properly if it failed
|
|
|
|
* now.
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
if (retval && capable(CAP_SYS_ADMIN))
|
2011-11-10 04:34:14 +08:00
|
|
|
return 1;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int uart_startup(struct tty_struct *tty, struct uart_state *state,
|
|
|
|
int init_hw)
|
|
|
|
{
|
|
|
|
struct tty_port *port = &state->port;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
if (port->flags & ASYNC_INITIALIZED)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the TTY IO error marker - we will only clear this
|
|
|
|
* once we have successfully opened the port.
|
|
|
|
*/
|
|
|
|
set_bit(TTY_IO_ERROR, &tty->flags);
|
|
|
|
|
|
|
|
retval = uart_port_startup(tty, state, init_hw);
|
|
|
|
if (!retval) {
|
|
|
|
set_bit(ASYNCB_INITIALIZED, &port->flags);
|
|
|
|
clear_bit(TTY_IO_ERROR, &tty->flags);
|
|
|
|
} else if (retval > 0)
|
2005-04-17 06:20:36 +08:00
|
|
|
retval = 0;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This routine will shutdown a serial port; interrupts are disabled, and
|
|
|
|
* DTR is dropped if the hangup on close termio flag is on. Calls to
|
|
|
|
* uart_shutdown are serialised by the per-port semaphore.
|
|
|
|
*/
|
2010-06-02 04:52:51 +08:00
|
|
|
static void uart_shutdown(struct tty_struct *tty, struct uart_state *state)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-20 04:13:30 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2009-09-20 04:13:31 +08:00
|
|
|
struct tty_port *port = &state->port;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
2005-11-13 23:28:51 +08:00
|
|
|
* Set the TTY IO error marker
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2009-01-02 21:49:21 +08:00
|
|
|
if (tty)
|
|
|
|
set_bit(TTY_IO_ERROR, &tty->flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
|
2005-11-13 23:28:51 +08:00
|
|
|
/*
|
|
|
|
* Turn off DTR and RTS early.
|
|
|
|
*/
|
2014-07-09 21:21:14 +08:00
|
|
|
if (uart_console(uport) && tty)
|
|
|
|
uport->cons->cflag = tty->termios.c_cflag;
|
|
|
|
|
2012-07-14 22:31:47 +08:00
|
|
|
if (!tty || (tty->termios.c_cflag & HUPCL))
|
2009-09-20 04:13:30 +08:00
|
|
|
uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
|
2005-11-13 23:28:51 +08:00
|
|
|
|
2011-11-10 04:33:51 +08:00
|
|
|
uart_port_shutdown(port);
|
2005-11-13 23:28:51 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
2011-10-20 02:52:01 +08:00
|
|
|
* It's possible for shutdown to be called after suspend if we get
|
|
|
|
* a DCD drop (hangup) at just the right time. Clear suspended bit so
|
|
|
|
* we don't try to resume a port that has been shutdown.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2011-10-20 02:52:01 +08:00
|
|
|
clear_bit(ASYNCB_SUSPENDED, &port->flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Free the transmit buffer page.
|
|
|
|
*/
|
2009-09-20 04:13:28 +08:00
|
|
|
if (state->xmit.buf) {
|
|
|
|
free_page((unsigned long)state->xmit.buf);
|
|
|
|
state->xmit.buf = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* uart_update_timeout - update per-port FIFO timeout.
|
|
|
|
* @port: uart_port structure describing the port
|
|
|
|
* @cflag: termios cflag value
|
|
|
|
* @baud: speed of the port
|
|
|
|
*
|
|
|
|
* Set the port FIFO timeout value. The @cflag value should
|
|
|
|
* reflect the actual hardware settings.
|
|
|
|
*/
|
|
|
|
void
|
|
|
|
uart_update_timeout(struct uart_port *port, unsigned int cflag,
|
|
|
|
unsigned int baud)
|
|
|
|
{
|
|
|
|
unsigned int bits;
|
|
|
|
|
|
|
|
/* byte size and parity */
|
|
|
|
switch (cflag & CSIZE) {
|
|
|
|
case CS5:
|
|
|
|
bits = 7;
|
|
|
|
break;
|
|
|
|
case CS6:
|
|
|
|
bits = 8;
|
|
|
|
break;
|
|
|
|
case CS7:
|
|
|
|
bits = 9;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
bits = 10;
|
2008-02-08 20:18:53 +08:00
|
|
|
break; /* CS8 */
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (cflag & CSTOPB)
|
|
|
|
bits++;
|
|
|
|
if (cflag & PARENB)
|
|
|
|
bits++;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The total number of bits to be transmitted in the fifo.
|
|
|
|
*/
|
|
|
|
bits = bits * port->fifosize;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Figure the timeout to send the above number of bits.
|
|
|
|
* Add .02 seconds of slop
|
|
|
|
*/
|
|
|
|
port->timeout = (HZ * bits) / baud + HZ/50;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(uart_update_timeout);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* uart_get_baud_rate - return baud rate for a particular port
|
|
|
|
* @port: uart_port structure describing the port in question.
|
|
|
|
* @termios: desired termios settings.
|
|
|
|
* @old: old termios (or NULL)
|
|
|
|
* @min: minimum acceptable baud rate
|
|
|
|
* @max: maximum acceptable baud rate
|
|
|
|
*
|
|
|
|
* Decode the termios structure into a numeric baud rate,
|
|
|
|
* taking account of the magic 38400 baud rate (with spd_*
|
|
|
|
* flags), and mapping the %B0 rate to 9600 baud.
|
|
|
|
*
|
|
|
|
* If the new baud rate is invalid, try the old termios setting.
|
|
|
|
* If it's still invalid, we try 9600 baud.
|
|
|
|
*
|
|
|
|
* Update the @termios structure to reflect the baud rate
|
2008-04-28 17:14:07 +08:00
|
|
|
* we're actually going to be using. Don't do this for the case
|
|
|
|
* where B0 is requested ("hang up").
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
unsigned int
|
2006-12-08 18:38:45 +08:00
|
|
|
uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
|
|
|
|
struct ktermios *old, unsigned int min, unsigned int max)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
unsigned int try, baud, altbaud = 38400;
|
2008-04-28 17:14:07 +08:00
|
|
|
int hung_up = 0;
|
2006-01-22 07:03:28 +08:00
|
|
|
upf_t flags = port->flags & UPF_SPD_MASK;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (flags == UPF_SPD_HI)
|
|
|
|
altbaud = 57600;
|
2009-10-25 21:18:26 +08:00
|
|
|
else if (flags == UPF_SPD_VHI)
|
2005-04-17 06:20:36 +08:00
|
|
|
altbaud = 115200;
|
2009-10-25 21:18:26 +08:00
|
|
|
else if (flags == UPF_SPD_SHI)
|
2005-04-17 06:20:36 +08:00
|
|
|
altbaud = 230400;
|
2009-10-25 21:18:26 +08:00
|
|
|
else if (flags == UPF_SPD_WARP)
|
2005-04-17 06:20:36 +08:00
|
|
|
altbaud = 460800;
|
|
|
|
|
|
|
|
for (try = 0; try < 2; try++) {
|
|
|
|
baud = tty_termios_baud_rate(termios);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The spd_hi, spd_vhi, spd_shi, spd_warp kludge...
|
|
|
|
* Die! Die! Die!
|
|
|
|
*/
|
2014-10-17 01:46:38 +08:00
|
|
|
if (try == 0 && baud == 38400)
|
2005-04-17 06:20:36 +08:00
|
|
|
baud = altbaud;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Special case: B0 rate.
|
|
|
|
*/
|
2008-04-28 17:14:07 +08:00
|
|
|
if (baud == 0) {
|
|
|
|
hung_up = 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
baud = 9600;
|
2008-04-28 17:14:07 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (baud >= min && baud <= max)
|
|
|
|
return baud;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Oops, the quotient was zero. Try again with
|
|
|
|
* the old baud rate if possible.
|
|
|
|
*/
|
|
|
|
termios->c_cflag &= ~CBAUD;
|
|
|
|
if (old) {
|
2008-02-05 14:27:53 +08:00
|
|
|
baud = tty_termios_baud_rate(old);
|
2008-04-28 17:14:07 +08:00
|
|
|
if (!hung_up)
|
|
|
|
tty_termios_encode_baud_rate(termios,
|
|
|
|
baud, baud);
|
2005-04-17 06:20:36 +08:00
|
|
|
old = NULL;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2010-01-05 00:26:21 +08:00
|
|
|
* As a last resort, if the range cannot be met then clip to
|
|
|
|
* the nearest chip supported rate.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2010-01-05 00:26:21 +08:00
|
|
|
if (!hung_up) {
|
|
|
|
if (baud <= min)
|
|
|
|
tty_termios_encode_baud_rate(termios,
|
|
|
|
min + 1, min + 1);
|
|
|
|
else
|
|
|
|
tty_termios_encode_baud_rate(termios,
|
|
|
|
max - 1, max - 1);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2010-01-05 00:26:21 +08:00
|
|
|
/* Should never happen */
|
|
|
|
WARN_ON(1);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(uart_get_baud_rate);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* uart_get_divisor - return uart clock divisor
|
|
|
|
* @port: uart_port structure describing the port.
|
|
|
|
* @baud: desired baud rate
|
|
|
|
*
|
|
|
|
* Calculate the uart clock divisor for the port.
|
|
|
|
*/
|
|
|
|
unsigned int
|
|
|
|
uart_get_divisor(struct uart_port *port, unsigned int baud)
|
|
|
|
{
|
|
|
|
unsigned int quot;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Old custom speed handling.
|
|
|
|
*/
|
|
|
|
if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)
|
|
|
|
quot = port->custom_divisor;
|
|
|
|
else
|
2011-12-20 18:47:44 +08:00
|
|
|
quot = DIV_ROUND_CLOSEST(port->uartclk, 16 * baud);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return quot;
|
|
|
|
}
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(uart_get_divisor);
|
|
|
|
|
2014-10-17 04:54:20 +08:00
|
|
|
/* Caller holds port mutex */
|
2010-06-02 04:52:51 +08:00
|
|
|
static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
|
|
|
|
struct ktermios *old_termios)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-20 04:13:30 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2006-12-08 18:38:45 +08:00
|
|
|
struct ktermios *termios;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we have no tty, termios, or the port does not exist,
|
|
|
|
* then we can't set the parameters for this port.
|
|
|
|
*/
|
2012-07-14 22:31:47 +08:00
|
|
|
if (!tty || uport->type == PORT_UNKNOWN)
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
|
2012-07-14 22:31:47 +08:00
|
|
|
termios = &tty->termios;
|
2014-06-16 21:17:09 +08:00
|
|
|
uport->ops->set_termios(uport, termios, old_termios);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
2014-09-11 03:06:24 +08:00
|
|
|
* Set modem status enables based on termios cflag
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2014-09-11 03:06:24 +08:00
|
|
|
spin_lock_irq(&uport->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (termios->c_cflag & CRTSCTS)
|
2014-09-11 03:06:24 +08:00
|
|
|
uport->status |= UPSTAT_CTS_ENABLE;
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
2014-09-11 03:06:24 +08:00
|
|
|
uport->status &= ~UPSTAT_CTS_ENABLE;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (termios->c_cflag & CLOCAL)
|
2014-09-11 03:06:24 +08:00
|
|
|
uport->status &= ~UPSTAT_DCD_ENABLE;
|
2005-04-17 06:20:36 +08:00
|
|
|
else
|
2014-09-11 03:06:24 +08:00
|
|
|
uport->status |= UPSTAT_DCD_ENABLE;
|
|
|
|
spin_unlock_irq(&uport->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-06-02 04:52:51 +08:00
|
|
|
static inline int __uart_put_char(struct uart_port *port,
|
|
|
|
struct circ_buf *circ, unsigned char c)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2008-04-30 15:54:11 +08:00
|
|
|
int ret = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!circ->buf)
|
2008-04-30 15:54:11 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
|
if (uart_circ_chars_free(circ) != 0) {
|
|
|
|
circ->buf[circ->head] = c;
|
|
|
|
circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);
|
2008-04-30 15:54:11 +08:00
|
|
|
ret = 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
2008-04-30 15:54:11 +08:00
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-04-30 15:54:11 +08:00
|
|
|
static int uart_put_char(struct tty_struct *tty, unsigned char ch)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
return __uart_put_char(state->uart_port, &state->xmit, ch);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void uart_flush_chars(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
uart_start(tty);
|
|
|
|
}
|
|
|
|
|
2010-06-02 04:52:51 +08:00
|
|
|
static int uart_write(struct tty_struct *tty,
|
|
|
|
const unsigned char *buf, int count)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2006-03-08 13:55:20 +08:00
|
|
|
struct uart_port *port;
|
|
|
|
struct circ_buf *circ;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long flags;
|
|
|
|
int c, ret = 0;
|
|
|
|
|
2006-03-08 13:55:20 +08:00
|
|
|
/*
|
|
|
|
* This means you called this function _after_ the port was
|
|
|
|
* closed. No cookie for you.
|
|
|
|
*/
|
2009-01-02 21:49:21 +08:00
|
|
|
if (!state) {
|
2006-03-08 13:55:20 +08:00
|
|
|
WARN_ON(1);
|
|
|
|
return -EL3HLT;
|
|
|
|
}
|
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
port = state->uart_port;
|
|
|
|
circ = &state->xmit;
|
2006-03-08 13:55:20 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!circ->buf)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
|
|
|
while (1) {
|
|
|
|
c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
|
|
|
|
if (count < c)
|
|
|
|
c = count;
|
|
|
|
if (c <= 0)
|
|
|
|
break;
|
|
|
|
memcpy(circ->buf + circ->head, buf, c);
|
|
|
|
circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
|
|
|
|
buf += c;
|
|
|
|
count -= c;
|
|
|
|
ret += c;
|
|
|
|
}
|
2014-10-17 04:54:26 +08:00
|
|
|
|
|
|
|
__uart_start(tty);
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int uart_write_room(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2008-04-30 15:54:13 +08:00
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
spin_lock_irqsave(&state->uart_port->lock, flags);
|
|
|
|
ret = uart_circ_chars_free(&state->xmit);
|
|
|
|
spin_unlock_irqrestore(&state->uart_port->lock, flags);
|
2008-04-30 15:54:13 +08:00
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int uart_chars_in_buffer(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2008-04-30 15:54:13 +08:00
|
|
|
unsigned long flags;
|
|
|
|
int ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
spin_lock_irqsave(&state->uart_port->lock, flags);
|
|
|
|
ret = uart_circ_chars_pending(&state->xmit);
|
|
|
|
spin_unlock_irqrestore(&state->uart_port->lock, flags);
|
2008-04-30 15:54:13 +08:00
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void uart_flush_buffer(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2008-05-07 11:42:27 +08:00
|
|
|
struct uart_port *port;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
2006-03-08 13:55:20 +08:00
|
|
|
/*
|
|
|
|
* This means you called this function _after_ the port was
|
|
|
|
* closed. No cookie for you.
|
|
|
|
*/
|
2009-01-02 21:49:21 +08:00
|
|
|
if (!state) {
|
2006-03-08 13:55:20 +08:00
|
|
|
WARN_ON(1);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
port = state->uart_port;
|
2007-05-07 05:48:52 +08:00
|
|
|
pr_debug("uart_flush_buffer(%d) called\n", tty->index);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
2009-09-20 04:13:28 +08:00
|
|
|
uart_circ_clear(&state->xmit);
|
2008-07-17 04:52:36 +08:00
|
|
|
if (port->ops->flush_buffer)
|
|
|
|
port->ops->flush_buffer(port);
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
|
tty_wakeup(tty);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This function is used to send a high-priority XON/XOFF character to
|
|
|
|
* the device
|
|
|
|
*/
|
|
|
|
static void uart_send_xchar(struct tty_struct *tty, char ch)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:28 +08:00
|
|
|
struct uart_port *port = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
if (port->ops->send_xchar)
|
|
|
|
port->ops->send_xchar(port, ch);
|
|
|
|
else {
|
2014-09-03 05:39:13 +08:00
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
port->x_char = ch;
|
2014-09-03 05:39:13 +08:00
|
|
|
if (ch)
|
2005-08-31 17:12:14 +08:00
|
|
|
port->ops->start_tx(port);
|
2014-09-03 05:39:13 +08:00
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void uart_throttle(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2012-04-18 00:23:14 +08:00
|
|
|
struct uart_port *port = state->uart_port;
|
2014-10-17 02:19:48 +08:00
|
|
|
upf_t mask = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (I_IXOFF(tty))
|
2012-04-18 00:23:14 +08:00
|
|
|
mask |= UPF_SOFT_FLOW;
|
|
|
|
if (tty->termios.c_cflag & CRTSCTS)
|
|
|
|
mask |= UPF_HARD_FLOW;
|
|
|
|
|
|
|
|
if (port->flags & mask) {
|
|
|
|
port->ops->throttle(port);
|
|
|
|
mask &= ~port->flags;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mask & UPF_SOFT_FLOW)
|
2005-04-17 06:20:36 +08:00
|
|
|
uart_send_xchar(tty, STOP_CHAR(tty));
|
|
|
|
|
2012-04-18 00:23:14 +08:00
|
|
|
if (mask & UPF_HARD_FLOW)
|
|
|
|
uart_clear_mctrl(port, TIOCM_RTS);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void uart_unthrottle(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:28 +08:00
|
|
|
struct uart_port *port = state->uart_port;
|
2014-10-17 02:19:48 +08:00
|
|
|
upf_t mask = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-04-18 00:23:14 +08:00
|
|
|
if (I_IXOFF(tty))
|
|
|
|
mask |= UPF_SOFT_FLOW;
|
|
|
|
if (tty->termios.c_cflag & CRTSCTS)
|
|
|
|
mask |= UPF_HARD_FLOW;
|
|
|
|
|
|
|
|
if (port->flags & mask) {
|
|
|
|
port->ops->unthrottle(port);
|
|
|
|
mask &= ~port->flags;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-09-03 05:39:14 +08:00
|
|
|
if (mask & UPF_SOFT_FLOW)
|
|
|
|
uart_send_xchar(tty, START_CHAR(tty));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-04-18 00:23:14 +08:00
|
|
|
if (mask & UPF_HARD_FLOW)
|
2005-04-17 06:20:36 +08:00
|
|
|
uart_set_mctrl(port, TIOCM_RTS);
|
|
|
|
}
|
|
|
|
|
2012-10-29 23:20:25 +08:00
|
|
|
static void do_uart_get_info(struct tty_port *port,
|
2012-09-04 23:34:45 +08:00
|
|
|
struct serial_struct *retinfo)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2012-10-29 23:20:25 +08:00
|
|
|
struct uart_state *state = container_of(port, struct uart_state, port);
|
2009-09-20 04:13:31 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2008-04-30 15:54:13 +08:00
|
|
|
|
2012-09-06 10:27:51 +08:00
|
|
|
memset(retinfo, 0, sizeof(*retinfo));
|
2008-04-30 15:54:13 +08:00
|
|
|
|
2012-09-04 23:34:45 +08:00
|
|
|
retinfo->type = uport->type;
|
|
|
|
retinfo->line = uport->line;
|
|
|
|
retinfo->port = uport->iobase;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (HIGH_BITS_OFFSET)
|
2012-09-04 23:34:45 +08:00
|
|
|
retinfo->port_high = (long) uport->iobase >> HIGH_BITS_OFFSET;
|
|
|
|
retinfo->irq = uport->irq;
|
|
|
|
retinfo->flags = uport->flags;
|
|
|
|
retinfo->xmit_fifo_size = uport->fifosize;
|
|
|
|
retinfo->baud_base = uport->uartclk / 16;
|
|
|
|
retinfo->close_delay = jiffies_to_msecs(port->close_delay) / 10;
|
|
|
|
retinfo->closing_wait = port->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
|
2005-04-17 06:20:36 +08:00
|
|
|
ASYNC_CLOSING_WAIT_NONE :
|
2011-11-10 04:33:45 +08:00
|
|
|
jiffies_to_msecs(port->closing_wait) / 10;
|
2012-09-04 23:34:45 +08:00
|
|
|
retinfo->custom_divisor = uport->custom_divisor;
|
|
|
|
retinfo->hub6 = uport->hub6;
|
|
|
|
retinfo->io_type = uport->iotype;
|
|
|
|
retinfo->iomem_reg_shift = uport->regshift;
|
|
|
|
retinfo->iomem_base = (void *)(unsigned long)uport->mapbase;
|
|
|
|
}
|
|
|
|
|
2012-10-29 23:20:25 +08:00
|
|
|
static void uart_get_info(struct tty_port *port,
|
|
|
|
struct serial_struct *retinfo)
|
2012-09-04 23:34:45 +08:00
|
|
|
{
|
|
|
|
/* Ensure the state we copy is consistent and no hardware changes
|
|
|
|
occur as we go */
|
|
|
|
mutex_lock(&port->mutex);
|
2012-10-29 23:20:25 +08:00
|
|
|
do_uart_get_info(port, retinfo);
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2012-10-29 23:20:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int uart_get_info_user(struct tty_port *port,
|
|
|
|
struct serial_struct __user *retinfo)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
uart_get_info(port, &tmp);
|
2008-04-30 15:54:13 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-09-04 23:34:45 +08:00
|
|
|
static int uart_set_info(struct tty_struct *tty, struct tty_port *port,
|
|
|
|
struct uart_state *state,
|
|
|
|
struct serial_struct *new_info)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-20 04:13:29 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long new_port;
|
2006-01-22 07:03:28 +08:00
|
|
|
unsigned int change_irq, change_port, closing_wait;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int old_custom_divisor, close_delay;
|
2006-01-22 07:03:28 +08:00
|
|
|
upf_t old_flags, new_flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
int retval = 0;
|
|
|
|
|
2012-09-04 23:34:45 +08:00
|
|
|
new_port = new_info->port;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (HIGH_BITS_OFFSET)
|
2012-09-04 23:34:45 +08:00
|
|
|
new_port += (unsigned long) new_info->port_high << HIGH_BITS_OFFSET;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-09-04 23:34:45 +08:00
|
|
|
new_info->irq = irq_canonicalize(new_info->irq);
|
|
|
|
close_delay = msecs_to_jiffies(new_info->close_delay * 10);
|
|
|
|
closing_wait = new_info->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
|
2011-11-10 04:33:45 +08:00
|
|
|
ASYNC_CLOSING_WAIT_NONE :
|
2012-09-04 23:34:45 +08:00
|
|
|
msecs_to_jiffies(new_info->closing_wait * 10);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
2009-09-20 04:13:29 +08:00
|
|
|
change_irq = !(uport->flags & UPF_FIXED_PORT)
|
2012-09-04 23:34:45 +08:00
|
|
|
&& new_info->irq != uport->irq;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Since changing the 'type' of the port changes its resource
|
|
|
|
* allocations, we should treat type changes the same as
|
|
|
|
* IO port changes.
|
|
|
|
*/
|
2009-09-20 04:13:29 +08:00
|
|
|
change_port = !(uport->flags & UPF_FIXED_PORT)
|
|
|
|
&& (new_port != uport->iobase ||
|
2012-09-04 23:34:45 +08:00
|
|
|
(unsigned long)new_info->iomem_base != uport->mapbase ||
|
|
|
|
new_info->hub6 != uport->hub6 ||
|
|
|
|
new_info->io_type != uport->iotype ||
|
|
|
|
new_info->iomem_reg_shift != uport->regshift ||
|
|
|
|
new_info->type != uport->type);
|
2009-09-20 04:13:29 +08:00
|
|
|
|
|
|
|
old_flags = uport->flags;
|
2012-09-04 23:34:45 +08:00
|
|
|
new_flags = new_info->flags;
|
2009-09-20 04:13:29 +08:00
|
|
|
old_custom_divisor = uport->custom_divisor;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN)) {
|
|
|
|
retval = -EPERM;
|
|
|
|
if (change_irq || change_port ||
|
2012-09-04 23:34:45 +08:00
|
|
|
(new_info->baud_base != uport->uartclk / 16) ||
|
2009-09-20 04:13:29 +08:00
|
|
|
(close_delay != port->close_delay) ||
|
|
|
|
(closing_wait != port->closing_wait) ||
|
2012-09-04 23:34:45 +08:00
|
|
|
(new_info->xmit_fifo_size &&
|
|
|
|
new_info->xmit_fifo_size != uport->fifosize) ||
|
2006-01-22 07:03:28 +08:00
|
|
|
(((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto exit;
|
2009-09-20 04:13:29 +08:00
|
|
|
uport->flags = ((uport->flags & ~UPF_USR_MASK) |
|
2006-01-22 07:03:28 +08:00
|
|
|
(new_flags & UPF_USR_MASK));
|
2012-09-04 23:34:45 +08:00
|
|
|
uport->custom_divisor = new_info->custom_divisor;
|
2005-04-17 06:20:36 +08:00
|
|
|
goto check_and_exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ask the low level driver to verify the settings.
|
|
|
|
*/
|
2009-09-20 04:13:29 +08:00
|
|
|
if (uport->ops->verify_port)
|
2012-09-04 23:34:45 +08:00
|
|
|
retval = uport->ops->verify_port(uport, new_info);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-09-04 23:34:45 +08:00
|
|
|
if ((new_info->irq >= nr_irqs) || (new_info->irq < 0) ||
|
|
|
|
(new_info->baud_base < 9600))
|
2005-04-17 06:20:36 +08:00
|
|
|
retval = -EINVAL;
|
|
|
|
|
|
|
|
if (retval)
|
|
|
|
goto exit;
|
|
|
|
|
|
|
|
if (change_port || change_irq) {
|
|
|
|
retval = -EBUSY;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Make sure that we are the sole user of this port.
|
|
|
|
*/
|
2009-09-20 04:13:32 +08:00
|
|
|
if (tty_port_users(port) > 1)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto exit;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We need to shutdown the serial port at the old
|
|
|
|
* port/type/irq combination.
|
|
|
|
*/
|
2010-06-02 04:52:51 +08:00
|
|
|
uart_shutdown(tty, state);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (change_port) {
|
|
|
|
unsigned long old_iobase, old_mapbase;
|
|
|
|
unsigned int old_type, old_iotype, old_hub6, old_shift;
|
|
|
|
|
2009-09-20 04:13:29 +08:00
|
|
|
old_iobase = uport->iobase;
|
|
|
|
old_mapbase = uport->mapbase;
|
|
|
|
old_type = uport->type;
|
|
|
|
old_hub6 = uport->hub6;
|
|
|
|
old_iotype = uport->iotype;
|
|
|
|
old_shift = uport->regshift;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Free and release old regions
|
|
|
|
*/
|
|
|
|
if (old_type != PORT_UNKNOWN)
|
2009-09-20 04:13:29 +08:00
|
|
|
uport->ops->release_port(uport);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:29 +08:00
|
|
|
uport->iobase = new_port;
|
2012-09-04 23:34:45 +08:00
|
|
|
uport->type = new_info->type;
|
|
|
|
uport->hub6 = new_info->hub6;
|
|
|
|
uport->iotype = new_info->io_type;
|
|
|
|
uport->regshift = new_info->iomem_reg_shift;
|
|
|
|
uport->mapbase = (unsigned long)new_info->iomem_base;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Claim and map the new regions
|
|
|
|
*/
|
2009-09-20 04:13:29 +08:00
|
|
|
if (uport->type != PORT_UNKNOWN) {
|
|
|
|
retval = uport->ops->request_port(uport);
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
|
|
|
/* Always success - Jean II */
|
|
|
|
retval = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If we fail to request resources for the
|
|
|
|
* new port, try to restore the old settings.
|
|
|
|
*/
|
2014-04-23 18:33:22 +08:00
|
|
|
if (retval) {
|
2009-09-20 04:13:29 +08:00
|
|
|
uport->iobase = old_iobase;
|
|
|
|
uport->type = old_type;
|
|
|
|
uport->hub6 = old_hub6;
|
|
|
|
uport->iotype = old_iotype;
|
|
|
|
uport->regshift = old_shift;
|
|
|
|
uport->mapbase = old_mapbase;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-04-23 18:33:22 +08:00
|
|
|
if (old_type != PORT_UNKNOWN) {
|
|
|
|
retval = uport->ops->request_port(uport);
|
|
|
|
/*
|
|
|
|
* If we failed to restore the old settings,
|
|
|
|
* we fail like this.
|
|
|
|
*/
|
|
|
|
if (retval)
|
|
|
|
uport->type = PORT_UNKNOWN;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* We failed anyway.
|
|
|
|
*/
|
|
|
|
retval = -EBUSY;
|
|
|
|
}
|
|
|
|
|
2008-02-08 20:18:53 +08:00
|
|
|
/* Added to return the correct error -Ram Gupta */
|
|
|
|
goto exit;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
serial: define FIXED_PORT flag for serial_core
At present, the serial core always allows setserial in userspace to change the
port address, irq and base clock of any serial port. That makes sense for
legacy ISA ports, but not for (say) embedded ns16550 compatible serial ports
at peculiar addresses. In these cases, the kernel code configuring the ports
must know exactly where they are, and their clocking arrangements (which can
be unusual on embedded boards). It doesn't make sense for userspace to change
these settings.
Therefore, this patch defines a UPF_FIXED_PORT flag for the uart_port
structure. If this flag is set when the serial port is configured, any
attempts to alter the port's type, io address, irq or base clock with
setserial are ignored.
In addition this patch uses the new flag for on-chip serial ports probed in
arch/powerpc/kernel/legacy_serial.c, and for other hard-wired serial ports
probed by drivers/serial/of_serial.c.
Signed-off-by: David Gibson <dwg@au1.ibm.com>
Cc: Russell King <rmk@arm.linux.org.uk>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-05-07 05:48:49 +08:00
|
|
|
if (change_irq)
|
2012-09-04 23:34:45 +08:00
|
|
|
uport->irq = new_info->irq;
|
2009-09-20 04:13:29 +08:00
|
|
|
if (!(uport->flags & UPF_FIXED_PORT))
|
2012-09-04 23:34:45 +08:00
|
|
|
uport->uartclk = new_info->baud_base * 16;
|
2009-09-20 04:13:29 +08:00
|
|
|
uport->flags = (uport->flags & ~UPF_CHANGE_MASK) |
|
2006-01-22 07:03:28 +08:00
|
|
|
(new_flags & UPF_CHANGE_MASK);
|
2012-09-04 23:34:45 +08:00
|
|
|
uport->custom_divisor = new_info->custom_divisor;
|
2009-09-20 04:13:29 +08:00
|
|
|
port->close_delay = close_delay;
|
|
|
|
port->closing_wait = closing_wait;
|
2012-09-04 23:34:45 +08:00
|
|
|
if (new_info->xmit_fifo_size)
|
|
|
|
uport->fifosize = new_info->xmit_fifo_size;
|
2013-01-03 22:53:05 +08:00
|
|
|
port->low_latency = (uport->flags & UPF_LOW_LATENCY) ? 1 : 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
check_and_exit:
|
|
|
|
retval = 0;
|
2009-09-20 04:13:29 +08:00
|
|
|
if (uport->type == PORT_UNKNOWN)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto exit;
|
2009-09-20 04:13:30 +08:00
|
|
|
if (port->flags & ASYNC_INITIALIZED) {
|
2009-09-20 04:13:29 +08:00
|
|
|
if (((old_flags ^ uport->flags) & UPF_SPD_MASK) ||
|
|
|
|
old_custom_divisor != uport->custom_divisor) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* If they're setting up a custom divisor or speed,
|
|
|
|
* instead of clearing it, then bitch about it. No
|
|
|
|
* need to rate-limit; it's CAP_SYS_ADMIN only.
|
|
|
|
*/
|
2009-09-20 04:13:29 +08:00
|
|
|
if (uport->flags & UPF_SPD_MASK) {
|
2005-04-17 06:20:36 +08:00
|
|
|
char buf[64];
|
2014-09-01 23:19:43 +08:00
|
|
|
|
|
|
|
dev_notice(uport->dev,
|
|
|
|
"%s sets custom speed on %s. This is deprecated.\n",
|
|
|
|
current->comm,
|
|
|
|
tty_name(port->tty, buf));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2010-06-02 04:52:51 +08:00
|
|
|
uart_change_speed(tty, state, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
} else
|
2010-06-02 04:52:51 +08:00
|
|
|
retval = uart_startup(tty, state, 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
exit:
|
2012-09-04 23:34:45 +08:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int uart_set_info_user(struct tty_struct *tty, struct uart_state *state,
|
|
|
|
struct serial_struct __user *newinfo)
|
|
|
|
{
|
|
|
|
struct serial_struct new_serial;
|
|
|
|
struct tty_port *port = &state->port;
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This semaphore protects port->count. It is also
|
|
|
|
* very useful to prevent opens. Also, take the
|
|
|
|
* port configuration semaphore to make sure that a
|
|
|
|
* module insertion/removal doesn't change anything
|
|
|
|
* under us.
|
|
|
|
*/
|
|
|
|
mutex_lock(&port->mutex);
|
|
|
|
retval = uart_set_info(tty, port, state, &new_serial);
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2010-06-02 04:52:51 +08:00
|
|
|
/**
|
|
|
|
* uart_get_lsr_info - get line status register info
|
|
|
|
* @tty: tty associated with the UART
|
|
|
|
* @state: UART being queried
|
|
|
|
* @value: returned modem value
|
|
|
|
*
|
|
|
|
* Note: uart_ioctl protects us against hangups.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2010-06-02 04:52:51 +08:00
|
|
|
static int uart_get_lsr_info(struct tty_struct *tty,
|
|
|
|
struct uart_state *state, unsigned int __user *value)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-20 04:13:29 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int result;
|
|
|
|
|
2009-09-20 04:13:29 +08:00
|
|
|
result = uport->ops->tx_empty(uport);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we're about to load something into the transmit
|
|
|
|
* register, we'll pretend the transmitter isn't empty to
|
|
|
|
* avoid a race condition (depending on when the transmit
|
|
|
|
* interrupt happens).
|
|
|
|
*/
|
2009-09-20 04:13:29 +08:00
|
|
|
if (uport->x_char ||
|
2009-09-20 04:13:28 +08:00
|
|
|
((uart_circ_chars_pending(&state->xmit) > 0) &&
|
2014-09-11 03:06:26 +08:00
|
|
|
!uart_tx_stopped(uport)))
|
2005-04-17 06:20:36 +08:00
|
|
|
result &= ~TIOCSER_TEMT;
|
2008-02-08 20:18:53 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return put_user(result, value);
|
|
|
|
}
|
|
|
|
|
2011-02-15 00:26:14 +08:00
|
|
|
static int uart_tiocmget(struct tty_struct *tty)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:31 +08:00
|
|
|
struct tty_port *port = &state->port;
|
2009-09-20 04:13:29 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
int result = -EIO;
|
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_lock(&port->mutex);
|
2011-02-15 00:26:14 +08:00
|
|
|
if (!(tty->flags & (1 << TTY_IO_ERROR))) {
|
2009-09-20 04:13:29 +08:00
|
|
|
result = uport->mctrl;
|
|
|
|
spin_lock_irq(&uport->lock);
|
|
|
|
result |= uport->ops->get_mctrl(uport);
|
|
|
|
spin_unlock_irq(&uport->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2011-02-15 00:26:50 +08:00
|
|
|
uart_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:29 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2009-09-20 04:13:31 +08:00
|
|
|
struct tty_port *port = &state->port;
|
2005-04-17 06:20:36 +08:00
|
|
|
int ret = -EIO;
|
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_lock(&port->mutex);
|
2011-02-15 00:26:50 +08:00
|
|
|
if (!(tty->flags & (1 << TTY_IO_ERROR))) {
|
2009-09-20 04:13:29 +08:00
|
|
|
uart_update_mctrl(uport, set, clear);
|
2005-04-17 06:20:36 +08:00
|
|
|
ret = 0;
|
|
|
|
}
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-07-22 18:18:03 +08:00
|
|
|
static int uart_break_ctl(struct tty_struct *tty, int break_state)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:31 +08:00
|
|
|
struct tty_port *port = &state->port;
|
2009-09-20 04:13:29 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_lock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:29 +08:00
|
|
|
if (uport->type != PORT_UNKNOWN)
|
|
|
|
uport->ops->break_ctl(uport, break_state);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2008-07-22 18:18:03 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-06-02 04:52:51 +08:00
|
|
|
static int uart_do_autoconfig(struct tty_struct *tty,struct uart_state *state)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-20 04:13:29 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2009-09-20 04:13:31 +08:00
|
|
|
struct tty_port *port = &state->port;
|
2005-04-17 06:20:36 +08:00
|
|
|
int flags, ret;
|
|
|
|
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
|
|
return -EPERM;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Take the per-port semaphore. This prevents count from
|
|
|
|
* changing, and hence any extra opens of the port while
|
|
|
|
* we're auto-configuring.
|
|
|
|
*/
|
2009-09-20 04:13:31 +08:00
|
|
|
if (mutex_lock_interruptible(&port->mutex))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ERESTARTSYS;
|
|
|
|
|
|
|
|
ret = -EBUSY;
|
2009-09-20 04:13:32 +08:00
|
|
|
if (tty_port_users(port) == 1) {
|
2010-06-02 04:52:51 +08:00
|
|
|
uart_shutdown(tty, state);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we already have a port type configured,
|
|
|
|
* we must release its resources.
|
|
|
|
*/
|
2009-09-20 04:13:29 +08:00
|
|
|
if (uport->type != PORT_UNKNOWN)
|
|
|
|
uport->ops->release_port(uport);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
flags = UART_CONFIG_TYPE;
|
2009-09-20 04:13:29 +08:00
|
|
|
if (uport->flags & UPF_AUTO_IRQ)
|
2005-04-17 06:20:36 +08:00
|
|
|
flags |= UART_CONFIG_IRQ;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This will claim the ports resources if
|
|
|
|
* a port is found.
|
|
|
|
*/
|
2009-09-20 04:13:29 +08:00
|
|
|
uport->ops->config_port(uport, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-06-02 04:52:51 +08:00
|
|
|
ret = uart_startup(tty, state, 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-06-03 22:54:43 +08:00
|
|
|
static void uart_enable_ms(struct uart_port *uport)
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
* Force modem status interrupts on
|
|
|
|
*/
|
|
|
|
if (uport->ops->enable_ms)
|
|
|
|
uport->ops->enable_ms(uport);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
|
|
|
|
* - mask passed in arg for lines of interest
|
|
|
|
* (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
|
|
|
|
* Caller should use TIOCGICOUNT to see which one it was
|
2009-09-20 04:13:31 +08:00
|
|
|
*
|
|
|
|
* FIXME: This wants extracting into a common all driver implementation
|
|
|
|
* of TIOCMWAIT using tty_port.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
static int
|
|
|
|
uart_wait_modem_status(struct uart_state *state, unsigned long arg)
|
|
|
|
{
|
2009-09-20 04:13:29 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2009-09-20 04:13:31 +08:00
|
|
|
struct tty_port *port = &state->port;
|
2005-04-17 06:20:36 +08:00
|
|
|
DECLARE_WAITQUEUE(wait, current);
|
|
|
|
struct uart_icount cprev, cnow;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* note the counters on entry
|
|
|
|
*/
|
2009-09-20 04:13:29 +08:00
|
|
|
spin_lock_irq(&uport->lock);
|
|
|
|
memcpy(&cprev, &uport->icount, sizeof(struct uart_icount));
|
2014-06-03 22:54:43 +08:00
|
|
|
uart_enable_ms(uport);
|
2009-09-20 04:13:29 +08:00
|
|
|
spin_unlock_irq(&uport->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
add_wait_queue(&port->delta_msr_wait, &wait);
|
2005-04-17 06:20:36 +08:00
|
|
|
for (;;) {
|
2009-09-20 04:13:29 +08:00
|
|
|
spin_lock_irq(&uport->lock);
|
|
|
|
memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
|
|
|
|
spin_unlock_irq(&uport->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
|
|
|
|
|
|
if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
|
|
|
|
((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
|
|
|
|
((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) ||
|
|
|
|
((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
|
2008-02-08 20:18:53 +08:00
|
|
|
ret = 0;
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
schedule();
|
|
|
|
|
|
|
|
/* see if a signal did it */
|
|
|
|
if (signal_pending(current)) {
|
|
|
|
ret = -ERESTARTSYS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
cprev = cnow;
|
|
|
|
}
|
|
|
|
|
|
|
|
current->state = TASK_RUNNING;
|
2009-09-20 04:13:31 +08:00
|
|
|
remove_wait_queue(&port->delta_msr_wait, &wait);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
|
|
|
|
* Return: write counters to the user passed counter struct
|
|
|
|
* NB: both 1->0 and 0->1 transitions are counted except for
|
|
|
|
* RI where only 0->1 is counted.
|
|
|
|
*/
|
2010-09-17 01:21:24 +08:00
|
|
|
static int uart_get_icount(struct tty_struct *tty,
|
|
|
|
struct serial_icounter_struct *icount)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-09-17 01:21:24 +08:00
|
|
|
struct uart_state *state = tty->driver_data;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct uart_icount cnow;
|
2009-09-20 04:13:29 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:29 +08:00
|
|
|
spin_lock_irq(&uport->lock);
|
|
|
|
memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
|
|
|
|
spin_unlock_irq(&uport->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-09-17 01:21:24 +08:00
|
|
|
icount->cts = cnow.cts;
|
|
|
|
icount->dsr = cnow.dsr;
|
|
|
|
icount->rng = cnow.rng;
|
|
|
|
icount->dcd = cnow.dcd;
|
|
|
|
icount->rx = cnow.rx;
|
|
|
|
icount->tx = cnow.tx;
|
|
|
|
icount->frame = cnow.frame;
|
|
|
|
icount->overrun = cnow.overrun;
|
|
|
|
icount->parity = cnow.parity;
|
|
|
|
icount->brk = cnow.brk;
|
|
|
|
icount->buf_overrun = cnow.buf_overrun;
|
|
|
|
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2014-11-07 05:46:13 +08:00
|
|
|
static int uart_get_rs485_config(struct uart_port *port,
|
|
|
|
struct serial_rs485 __user *rs485)
|
|
|
|
{
|
|
|
|
if (copy_to_user(rs485, &port->rs485, sizeof(port->rs485)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int uart_set_rs485_config(struct uart_port *port,
|
|
|
|
struct serial_rs485 __user *rs485_user)
|
|
|
|
{
|
|
|
|
struct serial_rs485 rs485;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
if (!port->rs485_config)
|
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
|
|
|
|
if (copy_from_user(&rs485, rs485_user, sizeof(*rs485_user)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
ret = port->rs485_config(port, &rs485);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (copy_to_user(rs485_user, &port->rs485, sizeof(port->rs485)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2008-04-30 15:53:28 +08:00
|
|
|
* Called via sys_ioctl. We can use spin_lock_irq() here.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
static int
|
2011-02-15 00:27:22 +08:00
|
|
|
uart_ioctl(struct tty_struct *tty, unsigned int cmd,
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long arg)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:31 +08:00
|
|
|
struct tty_port *port = &state->port;
|
2005-04-17 06:20:36 +08:00
|
|
|
void __user *uarg = (void __user *)arg;
|
|
|
|
int ret = -ENOIOCTLCMD;
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* These ioctls don't rely on the hardware to be present.
|
|
|
|
*/
|
|
|
|
switch (cmd) {
|
|
|
|
case TIOCGSERIAL:
|
2012-10-29 23:20:25 +08:00
|
|
|
ret = uart_get_info_user(port, uarg);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TIOCSSERIAL:
|
2014-10-17 04:54:20 +08:00
|
|
|
down_write(&tty->termios_rwsem);
|
2012-09-04 23:34:45 +08:00
|
|
|
ret = uart_set_info_user(tty, state, uarg);
|
2014-10-17 04:54:20 +08:00
|
|
|
up_write(&tty->termios_rwsem);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TIOCSERCONFIG:
|
2014-10-17 04:54:20 +08:00
|
|
|
down_write(&tty->termios_rwsem);
|
2010-06-02 04:52:51 +08:00
|
|
|
ret = uart_do_autoconfig(tty, state);
|
2014-10-17 04:54:20 +08:00
|
|
|
up_write(&tty->termios_rwsem);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
|
|
|
case TIOCSERGWILD: /* obsolete */
|
|
|
|
case TIOCSERSWILD: /* obsolete */
|
|
|
|
ret = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret != -ENOIOCTLCMD)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
if (tty->flags & (1 << TTY_IO_ERROR)) {
|
|
|
|
ret = -EIO;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following should only be used when hardware is present.
|
|
|
|
*/
|
|
|
|
switch (cmd) {
|
|
|
|
case TIOCMIWAIT:
|
|
|
|
ret = uart_wait_modem_status(state, arg);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ret != -ENOIOCTLCMD)
|
|
|
|
goto out;
|
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_lock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-02-15 00:27:22 +08:00
|
|
|
if (tty->flags & (1 << TTY_IO_ERROR)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
ret = -EIO;
|
|
|
|
goto out_up;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* All these rely on hardware being present and need to be
|
|
|
|
* protected against the tty being hung up.
|
|
|
|
*/
|
2014-11-06 16:22:59 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (cmd) {
|
2014-11-06 16:22:59 +08:00
|
|
|
case TIOCSERGETLSR: /* Get line status register */
|
|
|
|
ret = uart_get_lsr_info(tty, state, uarg);
|
|
|
|
break;
|
|
|
|
|
2014-11-07 05:46:13 +08:00
|
|
|
case TIOCGRS485:
|
|
|
|
ret = uart_get_rs485_config(state->uart_port, uarg);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case TIOCSRS485:
|
|
|
|
ret = uart_set_rs485_config(state->uart_port, uarg);
|
|
|
|
break;
|
2005-04-17 06:20:36 +08:00
|
|
|
default: {
|
2009-09-20 04:13:29 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
|
|
|
if (uport->ops->ioctl)
|
|
|
|
ret = uport->ops->ioctl(uport, cmd, arg);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-04-30 15:54:13 +08:00
|
|
|
out_up:
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2008-04-30 15:54:13 +08:00
|
|
|
out:
|
2005-04-17 06:20:36 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-06-05 01:35:03 +08:00
|
|
|
static void uart_set_ldisc(struct tty_struct *tty)
|
2008-06-03 22:18:54 +08:00
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:29 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2008-06-03 22:18:54 +08:00
|
|
|
|
2014-11-06 02:11:42 +08:00
|
|
|
if (uport->ops->set_ldisc) {
|
|
|
|
mutex_lock(&state->port.mutex);
|
2014-11-06 02:11:43 +08:00
|
|
|
uport->ops->set_ldisc(uport, &tty->termios);
|
2014-11-06 02:11:42 +08:00
|
|
|
mutex_unlock(&state->port.mutex);
|
|
|
|
}
|
2008-06-03 22:18:54 +08:00
|
|
|
}
|
|
|
|
|
2008-02-08 20:18:53 +08:00
|
|
|
static void uart_set_termios(struct tty_struct *tty,
|
|
|
|
struct ktermios *old_termios)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2012-09-24 18:13:15 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2012-07-14 22:31:47 +08:00
|
|
|
unsigned int cflag = tty->termios.c_cflag;
|
2012-04-17 23:34:13 +08:00
|
|
|
unsigned int iflag_mask = IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK;
|
|
|
|
bool sw_changed = false;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-04-17 23:34:13 +08:00
|
|
|
/*
|
|
|
|
* Drivers doing software flow control also need to know
|
|
|
|
* about changes to these input settings.
|
|
|
|
*/
|
|
|
|
if (uport->flags & UPF_SOFT_FLOW) {
|
|
|
|
iflag_mask |= IXANY|IXON|IXOFF;
|
|
|
|
sw_changed =
|
|
|
|
tty->termios.c_cc[VSTART] != old_termios->c_cc[VSTART] ||
|
|
|
|
tty->termios.c_cc[VSTOP] != old_termios->c_cc[VSTOP];
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* These are the bits that are used to setup various
|
2007-08-23 05:01:11 +08:00
|
|
|
* flags in the low level driver. We can ignore the Bfoo
|
|
|
|
* bits in c_cflag; c_[io]speed will always be set
|
|
|
|
* appropriately by set_termios() in tty_ioctl.c
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
if ((cflag ^ old_termios->c_cflag) == 0 &&
|
2012-07-14 22:31:47 +08:00
|
|
|
tty->termios.c_ospeed == old_termios->c_ospeed &&
|
|
|
|
tty->termios.c_ispeed == old_termios->c_ispeed &&
|
2012-04-17 23:34:13 +08:00
|
|
|
((tty->termios.c_iflag ^ old_termios->c_iflag) & iflag_mask) == 0 &&
|
|
|
|
!sw_changed) {
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
2008-04-30 15:53:28 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-10-17 04:54:20 +08:00
|
|
|
mutex_lock(&state->port.mutex);
|
2010-06-02 04:52:51 +08:00
|
|
|
uart_change_speed(tty, state, old_termios);
|
2014-10-17 04:54:20 +08:00
|
|
|
mutex_unlock(&state->port.mutex);
|
2014-06-16 21:17:09 +08:00
|
|
|
/* reload cflag from termios; port driver may have overriden flags */
|
|
|
|
cflag = tty->termios.c_cflag;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Handle transition to B0 status */
|
|
|
|
if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
|
2012-09-24 18:13:15 +08:00
|
|
|
uart_clear_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Handle transition away from B0 status */
|
2009-10-25 21:18:26 +08:00
|
|
|
else if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned int mask = TIOCM_DTR;
|
2014-09-03 05:39:11 +08:00
|
|
|
if (!(cflag & CRTSCTS) || !test_bit(TTY_THROTTLED, &tty->flags))
|
2005-04-17 06:20:36 +08:00
|
|
|
mask |= TIOCM_RTS;
|
2012-09-24 18:13:15 +08:00
|
|
|
uart_set_mctrl(uport, mask);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2012-04-17 23:41:10 +08:00
|
|
|
/*
|
|
|
|
* If the port is doing h/w assisted flow control, do nothing.
|
2014-09-11 03:06:26 +08:00
|
|
|
* We assume that port->hw_stopped has never been set.
|
2012-04-17 23:41:10 +08:00
|
|
|
*/
|
|
|
|
if (uport->flags & UPF_HARD_FLOW)
|
|
|
|
return;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Handle turning off CRTSCTS */
|
|
|
|
if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
|
2014-09-11 03:06:29 +08:00
|
|
|
spin_lock_irq(&uport->lock);
|
2014-09-11 03:06:26 +08:00
|
|
|
uport->hw_stopped = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
__uart_start(tty);
|
2014-09-11 03:06:29 +08:00
|
|
|
spin_unlock_irq(&uport->lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2005-06-30 01:40:53 +08:00
|
|
|
/* Handle turning on CRTSCTS */
|
2009-10-25 21:18:26 +08:00
|
|
|
else if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
|
2014-09-11 03:06:29 +08:00
|
|
|
spin_lock_irq(&uport->lock);
|
2012-09-24 18:13:15 +08:00
|
|
|
if (!(uport->ops->get_mctrl(uport) & TIOCM_CTS)) {
|
2014-09-11 03:06:26 +08:00
|
|
|
uport->hw_stopped = 1;
|
2012-09-24 18:13:15 +08:00
|
|
|
uport->ops->stop_tx(uport);
|
2005-06-30 01:40:53 +08:00
|
|
|
}
|
2014-09-11 03:06:29 +08:00
|
|
|
spin_unlock_irq(&uport->lock);
|
2005-06-30 01:40:53 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2012-12-27 12:43:41 +08:00
|
|
|
* Calls to uart_close() are serialised via the tty_lock in
|
|
|
|
* drivers/tty/tty_io.c:tty_release()
|
|
|
|
* drivers/tty/tty_io.c:do_tty_hangup()
|
|
|
|
* This runs from a workqueue and can sleep for a _short_ time only.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
static void uart_close(struct tty_struct *tty, struct file *filp)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:29 +08:00
|
|
|
struct tty_port *port;
|
|
|
|
struct uart_port *uport;
|
2010-06-02 04:52:57 +08:00
|
|
|
unsigned long flags;
|
2008-02-08 20:18:53 +08:00
|
|
|
|
2014-10-17 04:54:27 +08:00
|
|
|
if (!state) {
|
|
|
|
struct uart_driver *drv = tty->driver->driver_state;
|
|
|
|
|
|
|
|
state = drv->state + tty->index;
|
|
|
|
port = &state->port;
|
|
|
|
spin_lock_irq(&port->lock);
|
|
|
|
--port->count;
|
|
|
|
spin_unlock_irq(&port->lock);
|
2009-10-13 01:13:54 +08:00
|
|
|
return;
|
2014-10-17 04:54:27 +08:00
|
|
|
}
|
2009-10-13 01:13:54 +08:00
|
|
|
|
2009-09-20 04:13:29 +08:00
|
|
|
uport = state->uart_port;
|
|
|
|
port = &state->port;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
serial_core: Avoid NULL pointer dereference in uart_close()
When unbinding a serial driver that's being used as a serial console,
the kernel may crash with a NULL pointer dereference in a uart_*() function
called from uart_close () (e.g. uart_flush_buffer() or
uart_chars_in_buffer()).
To fix this, let uart_close() check for port->count == 0. If this is the
case, bail out early. Else tty_port_close_start() will make the port
counts inconsistent, printing out warnings like
tty_port_close_start: tty->count = 1 port count = 0.
and
tty_port_close_start: count = -1
and once uport == NULL, it will also crash.
Also fix the related crash in pr_debug() by checking for a non-NULL uport
first.
Detailed description:
On driver unbind, uart_remove_one_port() is called. Basically it;
- marks the port dead,
- calls tty_vhangup(),
- sets state->uart_port = NULL.
What will happen depends on whether the port is just in use by e.g. getty,
or was also opened as a console.
A. If the tty was not opened as a console:
- tty_vhangup() will (in __tty_hangup()):
- mark all file descriptors for this tty hung up by pointing them to
hung_up_tty_fops,
- call uart_hangup(), which sets port->count to 0.
- A subsequent uart_open() (this may be through /dev/ttyS*, or through
/dev/console if this is a serial console) will fail with -ENXIO as the
port was marked dead,
- uart_close() after the failed uart_open() will return early, as
tty_hung_up_p() (called from tty_port_close_start()) will notice it was
hung up.
B. If the tty was also opened as a console:
- tty_vhangup() will (in __tty_hangup()):
- mark non-console file descriptors for this tty hung up by pointing
them to hung_up_tty_fops,
- NOT call uart_hangup(), but instead call uart_close() for every
non-console file descriptor, so port->count will still have a
non-zero value afterwards.
- A subsequent uart_open() will fail with -ENXIO as the port was
marked dead,
- uart_close() after the failed uart_open() starts to misbehave:
- tty_hung_up_p() will not notice it was hung up,
- As port->count is non-zero, tty_port_close_start() will decrease
port->count, making the tty and port counts inconsistent. Later,
warnings like these will be printed:
tty_port_close_start: tty->count = 1 port count = 0.
and
tty_port_close_start: count = -1
- If all of this happens after state->uart_port was set to zero, a
NULL pointer dereference will happen.
Signed-off-by: Geert Uytterhoeven <geert+renesas@linux-m68k.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-03-17 21:10:59 +08:00
|
|
|
pr_debug("uart_close(%d) called\n", uport ? uport->line : -1);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
serial_core: Avoid NULL pointer dereference in uart_close()
When unbinding a serial driver that's being used as a serial console,
the kernel may crash with a NULL pointer dereference in a uart_*() function
called from uart_close () (e.g. uart_flush_buffer() or
uart_chars_in_buffer()).
To fix this, let uart_close() check for port->count == 0. If this is the
case, bail out early. Else tty_port_close_start() will make the port
counts inconsistent, printing out warnings like
tty_port_close_start: tty->count = 1 port count = 0.
and
tty_port_close_start: count = -1
and once uport == NULL, it will also crash.
Also fix the related crash in pr_debug() by checking for a non-NULL uport
first.
Detailed description:
On driver unbind, uart_remove_one_port() is called. Basically it;
- marks the port dead,
- calls tty_vhangup(),
- sets state->uart_port = NULL.
What will happen depends on whether the port is just in use by e.g. getty,
or was also opened as a console.
A. If the tty was not opened as a console:
- tty_vhangup() will (in __tty_hangup()):
- mark all file descriptors for this tty hung up by pointing them to
hung_up_tty_fops,
- call uart_hangup(), which sets port->count to 0.
- A subsequent uart_open() (this may be through /dev/ttyS*, or through
/dev/console if this is a serial console) will fail with -ENXIO as the
port was marked dead,
- uart_close() after the failed uart_open() will return early, as
tty_hung_up_p() (called from tty_port_close_start()) will notice it was
hung up.
B. If the tty was also opened as a console:
- tty_vhangup() will (in __tty_hangup()):
- mark non-console file descriptors for this tty hung up by pointing
them to hung_up_tty_fops,
- NOT call uart_hangup(), but instead call uart_close() for every
non-console file descriptor, so port->count will still have a
non-zero value afterwards.
- A subsequent uart_open() will fail with -ENXIO as the port was
marked dead,
- uart_close() after the failed uart_open() starts to misbehave:
- tty_hung_up_p() will not notice it was hung up,
- As port->count is non-zero, tty_port_close_start() will decrease
port->count, making the tty and port counts inconsistent. Later,
warnings like these will be printed:
tty_port_close_start: tty->count = 1 port count = 0.
and
tty_port_close_start: count = -1
- If all of this happens after state->uart_port was set to zero, a
NULL pointer dereference will happen.
Signed-off-by: Geert Uytterhoeven <geert+renesas@linux-m68k.org>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-03-17 21:10:59 +08:00
|
|
|
if (!port->count || tty_port_close_start(port, tty, filp) == 0)
|
2011-08-29 14:43:36 +08:00
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* At this point, we stop accepting input. To do this, we
|
|
|
|
* disable the receive line status interrupts.
|
|
|
|
*/
|
2009-09-20 04:13:30 +08:00
|
|
|
if (port->flags & ASYNC_INITIALIZED) {
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long flags;
|
2009-10-13 01:13:54 +08:00
|
|
|
spin_lock_irqsave(&uport->lock, flags);
|
2009-09-20 04:13:29 +08:00
|
|
|
uport->ops->stop_rx(uport);
|
2009-10-13 01:13:54 +08:00
|
|
|
spin_unlock_irqrestore(&uport->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Before we drop DTR, make sure the UART transmitter
|
|
|
|
* has completely drained; this is especially
|
|
|
|
* important if there is a transmit FIFO!
|
|
|
|
*/
|
2011-07-14 20:35:10 +08:00
|
|
|
uart_wait_until_sent(tty, uport->timeout);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2011-08-25 21:12:05 +08:00
|
|
|
mutex_lock(&port->mutex);
|
2010-06-02 04:52:51 +08:00
|
|
|
uart_shutdown(tty, state);
|
2009-09-20 04:13:33 +08:00
|
|
|
tty_port_tty_set(port, NULL);
|
2010-06-02 04:52:57 +08:00
|
|
|
tty->closing = 0;
|
2014-06-16 21:17:03 +08:00
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:29 +08:00
|
|
|
if (port->blocked_open) {
|
2010-06-02 04:52:57 +08:00
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
2009-09-20 04:13:29 +08:00
|
|
|
if (port->close_delay)
|
2014-10-17 04:54:23 +08:00
|
|
|
msleep_interruptible(jiffies_to_msecs(port->close_delay));
|
2010-06-02 04:52:57 +08:00
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
2009-09-20 04:13:29 +08:00
|
|
|
} else if (!uart_console(uport)) {
|
2010-06-02 04:52:57 +08:00
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
2012-12-07 18:36:08 +08:00
|
|
|
uart_change_pm(state, UART_PM_STATE_OFF);
|
2010-06-02 04:52:57 +08:00
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wake up anyone trying to open this port.
|
|
|
|
*/
|
2009-09-20 04:13:30 +08:00
|
|
|
clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
|
2011-08-25 21:12:04 +08:00
|
|
|
clear_bit(ASYNCB_CLOSING, &port->flags);
|
2010-06-02 04:52:57 +08:00
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
2009-09-20 04:13:29 +08:00
|
|
|
wake_up_interruptible(&port->open_wait);
|
2011-08-25 21:12:04 +08:00
|
|
|
wake_up_interruptible(&port->close_wait);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2014-10-17 04:54:19 +08:00
|
|
|
|
|
|
|
tty_ldisc_flush(tty);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2011-07-14 20:35:10 +08:00
|
|
|
static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2011-07-14 20:35:10 +08:00
|
|
|
struct uart_state *state = tty->driver_data;
|
|
|
|
struct uart_port *port = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long char_time, expire;
|
|
|
|
|
|
|
|
if (port->type == PORT_UNKNOWN || port->fifosize == 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Set the check interval to be 1/5 of the estimated time to
|
|
|
|
* send a single character, and make it at least 1. The check
|
|
|
|
* interval should also be less than the timeout.
|
|
|
|
*
|
|
|
|
* Note: we have to use pretty tight timings here to satisfy
|
|
|
|
* the NIST-PCTS.
|
|
|
|
*/
|
|
|
|
char_time = (port->timeout - HZ/50) / port->fifosize;
|
|
|
|
char_time = char_time / 5;
|
|
|
|
if (char_time == 0)
|
|
|
|
char_time = 1;
|
|
|
|
if (timeout && timeout < char_time)
|
|
|
|
char_time = timeout;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If the transmitter hasn't cleared in twice the approximate
|
|
|
|
* amount of time to send the entire FIFO, it probably won't
|
|
|
|
* ever clear. This assumes the UART isn't doing flow
|
|
|
|
* control, which is currently the case. Hence, if it ever
|
|
|
|
* takes longer than port->timeout, this is probably due to a
|
|
|
|
* UART bug of some kind. So, we clamp the timeout parameter at
|
|
|
|
* 2*port->timeout.
|
|
|
|
*/
|
|
|
|
if (timeout == 0 || timeout > 2 * port->timeout)
|
|
|
|
timeout = 2 * port->timeout;
|
|
|
|
|
|
|
|
expire = jiffies + timeout;
|
|
|
|
|
2007-05-07 05:48:52 +08:00
|
|
|
pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n",
|
2008-02-08 20:18:53 +08:00
|
|
|
port->line, jiffies, expire);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check whether the transmitter is empty every 'char_time'.
|
|
|
|
* 'timeout' / 'expire' give us the maximum amount of time
|
|
|
|
* we wait.
|
|
|
|
*/
|
|
|
|
while (!port->ops->tx_empty(port)) {
|
|
|
|
msleep_interruptible(jiffies_to_msecs(char_time));
|
|
|
|
if (signal_pending(current))
|
|
|
|
break;
|
|
|
|
if (time_after(jiffies, expire))
|
|
|
|
break;
|
|
|
|
}
|
2010-06-02 04:53:07 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2012-12-27 12:43:41 +08:00
|
|
|
* Calls to uart_hangup() are serialised by the tty_lock in
|
|
|
|
* drivers/tty/tty_io.c:do_tty_hangup()
|
|
|
|
* This runs from a workqueue and can sleep for a _short_ time only.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
static void uart_hangup(struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
struct uart_state *state = tty->driver_data;
|
2009-09-20 04:13:29 +08:00
|
|
|
struct tty_port *port = &state->port;
|
2010-06-02 04:52:57 +08:00
|
|
|
unsigned long flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
pr_debug("uart_hangup(%d)\n", state->uart_port->line);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_lock(&port->mutex);
|
2009-09-20 04:13:30 +08:00
|
|
|
if (port->flags & ASYNC_NORMAL_ACTIVE) {
|
2005-04-17 06:20:36 +08:00
|
|
|
uart_flush_buffer(tty);
|
2010-06-02 04:52:51 +08:00
|
|
|
uart_shutdown(tty, state);
|
2010-06-02 04:52:57 +08:00
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
2009-09-20 04:13:29 +08:00
|
|
|
port->count = 0;
|
2009-09-20 04:13:30 +08:00
|
|
|
clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
|
2010-06-02 04:52:57 +08:00
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
2009-09-20 04:13:33 +08:00
|
|
|
tty_port_tty_set(port, NULL);
|
serial_core: Fix pm imbalance on unbind
When a serial port is closed, uart_close() takes care of shutting down the
hardware, and powering it down.
When a serial port is unbound while in use, uart_close() bypasses all of
this, as this is supposed to be done through uart_hangup() (invoked via
tty_vhangup() in uart_remove_one_port()).
However, uart_hangup() does not set the hardware's power state, leaving it
powered up. This may also lead to unbounded nesting counts in clock and
power management, depending on their internal implementation.
Make sure to power down the port in uart_hangup(), except when the port is
used as a serial console.
For serial consoles, this operation must be postponed until after the port
becomes completely unused. This case is not fixed yet, as it depends on a
(future) fix for the tty->count vs. port->count imbalance on failed
uart_open().
After this, the module clock used by the sh-sci driver is disabled on
unbind while the serial port is in use.
Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2014-03-27 18:40:39 +08:00
|
|
|
if (!uart_console(state->uart_port))
|
|
|
|
uart_change_pm(state, UART_PM_STATE_OFF);
|
2009-09-20 04:13:29 +08:00
|
|
|
wake_up_interruptible(&port->open_wait);
|
2009-09-20 04:13:31 +08:00
|
|
|
wake_up_interruptible(&port->delta_msr_wait);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2011-11-10 04:33:50 +08:00
|
|
|
static int uart_port_activate(struct tty_port *port, struct tty_struct *tty)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void uart_port_shutdown(struct tty_port *port)
|
|
|
|
{
|
2011-11-10 04:33:51 +08:00
|
|
|
struct uart_state *state = container_of(port, struct uart_state, port);
|
|
|
|
struct uart_port *uport = state->uart_port;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* clear delta_msr_wait queue to avoid mem leaks: we may free
|
|
|
|
* the irq here so the queue might never be woken up. Note
|
|
|
|
* that we won't end up waiting on delta_msr_wait again since
|
|
|
|
* any outstanding file descriptors should be pointing at
|
|
|
|
* hung_up_tty_fops now.
|
|
|
|
*/
|
|
|
|
wake_up_interruptible(&port->delta_msr_wait);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Free the IRQ and disable the port.
|
|
|
|
*/
|
|
|
|
uport->ops->shutdown(uport);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Ensure that the IRQ handler isn't running on another CPU.
|
|
|
|
*/
|
|
|
|
synchronize_irq(uport->irq);
|
2011-11-10 04:33:50 +08:00
|
|
|
}
|
|
|
|
|
2010-06-02 04:52:58 +08:00
|
|
|
static int uart_carrier_raised(struct tty_port *port)
|
|
|
|
{
|
|
|
|
struct uart_state *state = container_of(port, struct uart_state, port);
|
|
|
|
struct uart_port *uport = state->uart_port;
|
|
|
|
int mctrl;
|
|
|
|
spin_lock_irq(&uport->lock);
|
2014-06-03 22:54:43 +08:00
|
|
|
uart_enable_ms(uport);
|
2010-06-02 04:52:58 +08:00
|
|
|
mctrl = uport->ops->get_mctrl(uport);
|
|
|
|
spin_unlock_irq(&uport->lock);
|
|
|
|
if (mctrl & TIOCM_CAR)
|
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void uart_dtr_rts(struct tty_port *port, int onoff)
|
|
|
|
{
|
|
|
|
struct uart_state *state = container_of(port, struct uart_state, port);
|
|
|
|
struct uart_port *uport = state->uart_port;
|
2010-06-02 04:52:59 +08:00
|
|
|
|
2011-03-30 06:10:57 +08:00
|
|
|
if (onoff)
|
2010-06-02 04:52:58 +08:00
|
|
|
uart_set_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
|
|
|
|
else
|
|
|
|
uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2012-12-27 12:43:41 +08:00
|
|
|
* Calls to uart_open are serialised by the tty_lock in
|
|
|
|
* drivers/tty/tty_io.c:tty_open()
|
2005-04-17 06:20:36 +08:00
|
|
|
* Note that if this fails, then uart_close() _will_ be called.
|
|
|
|
*
|
|
|
|
* In time, we want to scrap the "opening nonpresent ports"
|
|
|
|
* behaviour and implement an alternative way for setserial
|
|
|
|
* to set base addresses/ports/types. This will allow us to
|
|
|
|
* get rid of a certain amount of extra tests.
|
|
|
|
*/
|
|
|
|
static int uart_open(struct tty_struct *tty, struct file *filp)
|
|
|
|
{
|
|
|
|
struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
|
|
|
|
int retval, line = tty->index;
|
2011-11-10 04:33:49 +08:00
|
|
|
struct uart_state *state = drv->state + line;
|
|
|
|
struct tty_port *port = &state->port;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-05-07 05:48:52 +08:00
|
|
|
pr_debug("uart_open(%d) called\n", line);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-10-17 04:54:27 +08:00
|
|
|
spin_lock_irq(&port->lock);
|
|
|
|
++port->count;
|
|
|
|
spin_unlock_irq(&port->lock);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2011-11-10 04:33:49 +08:00
|
|
|
* We take the semaphore here to guarantee that we won't 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
|
|
|
|
* state->port.tty will always contain something reasonable.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2011-11-10 04:33:49 +08:00
|
|
|
if (mutex_lock_interruptible(&port->mutex)) {
|
|
|
|
retval = -ERESTARTSYS;
|
|
|
|
goto end;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!state->uart_port || state->uart_port->flags & UPF_DEAD) {
|
|
|
|
retval = -ENXIO;
|
2014-10-17 04:54:27 +08:00
|
|
|
goto err_unlock;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
tty->driver_data = state;
|
2009-09-20 04:13:28 +08:00
|
|
|
state->uart_port->state = state;
|
2013-01-03 22:53:05 +08:00
|
|
|
state->port.low_latency =
|
|
|
|
(state->uart_port->flags & UPF_LOW_LATENCY) ? 1 : 0;
|
2009-09-20 04:13:33 +08:00
|
|
|
tty_port_tty_set(port, tty);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Start up the serial port.
|
|
|
|
*/
|
2010-06-02 04:52:51 +08:00
|
|
|
retval = uart_startup(tty, state, 0);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* If we succeeded, wait until the port is ready.
|
|
|
|
*/
|
2010-06-02 04:52:57 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (retval == 0)
|
2010-06-02 04:53:00 +08:00
|
|
|
retval = tty_port_block_til_ready(port, tty, filp);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-11-10 04:33:49 +08:00
|
|
|
end:
|
2005-04-17 06:20:36 +08:00
|
|
|
return retval;
|
2014-10-17 04:54:27 +08:00
|
|
|
err_unlock:
|
2011-11-10 04:33:49 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
|
|
|
goto end;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static const char *uart_type(struct uart_port *port)
|
|
|
|
{
|
|
|
|
const char *str = NULL;
|
|
|
|
|
|
|
|
if (port->ops->type)
|
|
|
|
str = port->ops->type(port);
|
|
|
|
|
|
|
|
if (!str)
|
|
|
|
str = "unknown";
|
|
|
|
|
|
|
|
return str;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
|
2009-04-01 06:19:21 +08:00
|
|
|
static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct uart_state *state = drv->state + i;
|
2009-09-20 04:13:31 +08:00
|
|
|
struct tty_port *port = &state->port;
|
2012-12-07 18:36:08 +08:00
|
|
|
enum uart_pm_state pm_state;
|
2009-09-20 04:13:31 +08:00
|
|
|
struct uart_port *uport = state->uart_port;
|
2005-04-17 06:20:36 +08:00
|
|
|
char stat_buf[32];
|
|
|
|
unsigned int status;
|
2009-04-01 06:19:21 +08:00
|
|
|
int mmio;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
if (!uport)
|
2009-04-01 06:19:21 +08:00
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mmio = uport->iotype >= UPIO_MEM;
|
2009-04-01 06:19:21 +08:00
|
|
|
seq_printf(m, "%d: uart:%s %s%08llX irq:%d",
|
2009-09-20 04:13:31 +08:00
|
|
|
uport->line, uart_type(uport),
|
2006-09-04 04:04:20 +08:00
|
|
|
mmio ? "mmio:0x" : "port:",
|
2009-09-20 04:13:31 +08:00
|
|
|
mmio ? (unsigned long long)uport->mapbase
|
|
|
|
: (unsigned long long)uport->iobase,
|
|
|
|
uport->irq);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
if (uport->type == PORT_UNKNOWN) {
|
2009-04-01 06:19:21 +08:00
|
|
|
seq_putc(m, '\n');
|
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2008-02-08 20:18:53 +08:00
|
|
|
if (capable(CAP_SYS_ADMIN)) {
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_lock(&port->mutex);
|
2007-02-14 16:33:06 +08:00
|
|
|
pm_state = state->pm_state;
|
2012-12-07 18:36:08 +08:00
|
|
|
if (pm_state != UART_PM_STATE_ON)
|
|
|
|
uart_change_pm(state, UART_PM_STATE_ON);
|
2009-09-20 04:13:31 +08:00
|
|
|
spin_lock_irq(&uport->lock);
|
|
|
|
status = uport->ops->get_mctrl(uport);
|
|
|
|
spin_unlock_irq(&uport->lock);
|
2012-12-07 18:36:08 +08:00
|
|
|
if (pm_state != UART_PM_STATE_ON)
|
2007-02-14 16:33:06 +08:00
|
|
|
uart_change_pm(state, pm_state);
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-04-01 06:19:21 +08:00
|
|
|
seq_printf(m, " tx:%d rx:%d",
|
2009-09-20 04:13:31 +08:00
|
|
|
uport->icount.tx, uport->icount.rx);
|
|
|
|
if (uport->icount.frame)
|
2009-04-01 06:19:21 +08:00
|
|
|
seq_printf(m, " fe:%d",
|
2009-09-20 04:13:31 +08:00
|
|
|
uport->icount.frame);
|
|
|
|
if (uport->icount.parity)
|
2009-04-01 06:19:21 +08:00
|
|
|
seq_printf(m, " pe:%d",
|
2009-09-20 04:13:31 +08:00
|
|
|
uport->icount.parity);
|
|
|
|
if (uport->icount.brk)
|
2009-04-01 06:19:21 +08:00
|
|
|
seq_printf(m, " brk:%d",
|
2009-09-20 04:13:31 +08:00
|
|
|
uport->icount.brk);
|
|
|
|
if (uport->icount.overrun)
|
2009-04-01 06:19:21 +08:00
|
|
|
seq_printf(m, " oe:%d",
|
2009-09-20 04:13:31 +08:00
|
|
|
uport->icount.overrun);
|
2008-02-08 20:18:53 +08:00
|
|
|
|
|
|
|
#define INFOBIT(bit, str) \
|
2009-09-20 04:13:31 +08:00
|
|
|
if (uport->mctrl & (bit)) \
|
2005-04-17 06:20:36 +08:00
|
|
|
strncat(stat_buf, (str), sizeof(stat_buf) - \
|
|
|
|
strlen(stat_buf) - 2)
|
2008-02-08 20:18:53 +08:00
|
|
|
#define STATBIT(bit, str) \
|
2005-04-17 06:20:36 +08:00
|
|
|
if (status & (bit)) \
|
|
|
|
strncat(stat_buf, (str), sizeof(stat_buf) - \
|
|
|
|
strlen(stat_buf) - 2)
|
|
|
|
|
|
|
|
stat_buf[0] = '\0';
|
|
|
|
stat_buf[1] = '\0';
|
|
|
|
INFOBIT(TIOCM_RTS, "|RTS");
|
|
|
|
STATBIT(TIOCM_CTS, "|CTS");
|
|
|
|
INFOBIT(TIOCM_DTR, "|DTR");
|
|
|
|
STATBIT(TIOCM_DSR, "|DSR");
|
|
|
|
STATBIT(TIOCM_CAR, "|CD");
|
|
|
|
STATBIT(TIOCM_RNG, "|RI");
|
|
|
|
if (stat_buf[0])
|
|
|
|
stat_buf[0] = ' ';
|
2008-02-08 20:18:53 +08:00
|
|
|
|
2009-04-01 06:19:21 +08:00
|
|
|
seq_puts(m, stat_buf);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-04-01 06:19:21 +08:00
|
|
|
seq_putc(m, '\n');
|
2005-04-17 06:20:36 +08:00
|
|
|
#undef STATBIT
|
|
|
|
#undef INFOBIT
|
|
|
|
}
|
|
|
|
|
2009-04-01 06:19:21 +08:00
|
|
|
static int uart_proc_show(struct seq_file *m, void *v)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-04-02 05:30:04 +08:00
|
|
|
struct tty_driver *ttydrv = m->private;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct uart_driver *drv = ttydrv->driver_state;
|
2009-04-01 06:19:21 +08:00
|
|
|
int i;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-04-01 06:19:21 +08:00
|
|
|
seq_printf(m, "serinfo:1.0 driver%s%s revision:%s\n",
|
2005-04-17 06:20:36 +08:00
|
|
|
"", "", "");
|
2009-04-01 06:19:21 +08:00
|
|
|
for (i = 0; i < drv->nr; i++)
|
|
|
|
uart_line_info(m, drv, i);
|
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2009-04-01 06:19:21 +08:00
|
|
|
|
|
|
|
static int uart_proc_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2013-04-01 06:16:14 +08:00
|
|
|
return single_open(file, uart_proc_show, PDE_DATA(inode));
|
2009-04-01 06:19:21 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations uart_proc_fops = {
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = uart_proc_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
2008-03-08 07:51:16 +08:00
|
|
|
#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(CONFIG_CONSOLE_POLL)
|
2006-03-21 04:00:09 +08:00
|
|
|
/*
|
|
|
|
* uart_console_write - write a console message to a serial port
|
|
|
|
* @port: the port to write the message
|
|
|
|
* @s: array of characters
|
|
|
|
* @count: number of characters in string to write
|
|
|
|
* @write: function to write character to port
|
|
|
|
*/
|
|
|
|
void uart_console_write(struct uart_port *port, const char *s,
|
|
|
|
unsigned int count,
|
|
|
|
void (*putchar)(struct uart_port *, int))
|
|
|
|
{
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < count; i++, s++) {
|
|
|
|
if (*s == '\n')
|
|
|
|
putchar(port, '\r');
|
|
|
|
putchar(port, *s);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(uart_console_write);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Check whether an invalid uart number has been specified, and
|
|
|
|
* if so, search for the first available port that does have
|
|
|
|
* console support.
|
|
|
|
*/
|
|
|
|
struct uart_port * __init
|
|
|
|
uart_get_console(struct uart_port *ports, int nr, struct console *co)
|
|
|
|
{
|
|
|
|
int idx = co->index;
|
|
|
|
|
|
|
|
if (idx < 0 || idx >= nr || (ports[idx].iobase == 0 &&
|
|
|
|
ports[idx].membase == NULL))
|
|
|
|
for (idx = 0; idx < nr; idx++)
|
|
|
|
if (ports[idx].iobase != 0 ||
|
|
|
|
ports[idx].membase != NULL)
|
|
|
|
break;
|
|
|
|
|
|
|
|
co->index = idx;
|
|
|
|
|
|
|
|
return ports + idx;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2014-03-11 18:23:35 +08:00
|
|
|
* uart_parse_options - Parse serial port baud/parity/bits/flow control.
|
2005-04-17 06:20:36 +08:00
|
|
|
* @options: pointer to option string
|
|
|
|
* @baud: pointer to an 'int' variable for the baud rate.
|
|
|
|
* @parity: pointer to an 'int' variable for the parity.
|
|
|
|
* @bits: pointer to an 'int' variable for the number of data bits.
|
|
|
|
* @flow: pointer to an 'int' variable for the flow control character.
|
|
|
|
*
|
|
|
|
* uart_parse_options decodes a string containing the serial console
|
|
|
|
* options. The format of the string is <baud><parity><bits><flow>,
|
|
|
|
* eg: 115200n8r
|
|
|
|
*/
|
2008-04-18 02:05:37 +08:00
|
|
|
void
|
2005-04-17 06:20:36 +08:00
|
|
|
uart_parse_options(char *options, int *baud, int *parity, int *bits, int *flow)
|
|
|
|
{
|
|
|
|
char *s = options;
|
|
|
|
|
|
|
|
*baud = simple_strtoul(s, NULL, 10);
|
|
|
|
while (*s >= '0' && *s <= '9')
|
|
|
|
s++;
|
|
|
|
if (*s)
|
|
|
|
*parity = *s++;
|
|
|
|
if (*s)
|
|
|
|
*bits = *s++ - '0';
|
|
|
|
if (*s)
|
|
|
|
*flow = *s;
|
|
|
|
}
|
2008-04-18 02:05:37 +08:00
|
|
|
EXPORT_SYMBOL_GPL(uart_parse_options);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
struct baud_rates {
|
|
|
|
unsigned int rate;
|
|
|
|
unsigned int cflag;
|
|
|
|
};
|
|
|
|
|
2005-11-29 05:04:11 +08:00
|
|
|
static const struct baud_rates baud_rates[] = {
|
2005-04-17 06:20:36 +08:00
|
|
|
{ 921600, B921600 },
|
|
|
|
{ 460800, B460800 },
|
|
|
|
{ 230400, B230400 },
|
|
|
|
{ 115200, B115200 },
|
|
|
|
{ 57600, B57600 },
|
|
|
|
{ 38400, B38400 },
|
|
|
|
{ 19200, B19200 },
|
|
|
|
{ 9600, B9600 },
|
|
|
|
{ 4800, B4800 },
|
|
|
|
{ 2400, B2400 },
|
|
|
|
{ 1200, B1200 },
|
|
|
|
{ 0, B38400 }
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* uart_set_options - setup the serial console parameters
|
|
|
|
* @port: pointer to the serial ports uart_port structure
|
|
|
|
* @co: console pointer
|
|
|
|
* @baud: baud rate
|
|
|
|
* @parity: parity character - 'n' (none), 'o' (odd), 'e' (even)
|
|
|
|
* @bits: number of data bits
|
|
|
|
* @flow: flow control character - 'r' (rts)
|
|
|
|
*/
|
2008-04-18 02:05:37 +08:00
|
|
|
int
|
2005-04-17 06:20:36 +08:00
|
|
|
uart_set_options(struct uart_port *port, struct console *co,
|
|
|
|
int baud, int parity, int bits, int flow)
|
|
|
|
{
|
2006-12-08 18:38:45 +08:00
|
|
|
struct ktermios termios;
|
2007-10-18 16:24:16 +08:00
|
|
|
static struct ktermios dummy;
|
2005-04-17 06:20:36 +08:00
|
|
|
int i;
|
|
|
|
|
2005-07-04 04:05:45 +08:00
|
|
|
/*
|
|
|
|
* Ensure that the serial console lock is initialised
|
|
|
|
* early.
|
2013-10-18 04:56:47 +08:00
|
|
|
* If this port is a console, then the spinlock is already
|
|
|
|
* initialised.
|
2005-07-04 04:05:45 +08:00
|
|
|
*/
|
2013-10-18 04:56:47 +08:00
|
|
|
if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) {
|
|
|
|
spin_lock_init(&port->lock);
|
|
|
|
lockdep_set_class(&port->lock, &port_lock_key);
|
|
|
|
}
|
2005-07-04 04:05:45 +08:00
|
|
|
|
2006-12-08 18:38:45 +08:00
|
|
|
memset(&termios, 0, sizeof(struct ktermios));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
termios.c_cflag = CREAD | HUPCL | CLOCAL;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Construct a cflag setting.
|
|
|
|
*/
|
|
|
|
for (i = 0; baud_rates[i].rate; i++)
|
|
|
|
if (baud_rates[i].rate <= baud)
|
|
|
|
break;
|
|
|
|
|
|
|
|
termios.c_cflag |= baud_rates[i].cflag;
|
|
|
|
|
|
|
|
if (bits == 7)
|
|
|
|
termios.c_cflag |= CS7;
|
|
|
|
else
|
|
|
|
termios.c_cflag |= CS8;
|
|
|
|
|
|
|
|
switch (parity) {
|
|
|
|
case 'o': case 'O':
|
|
|
|
termios.c_cflag |= PARODD;
|
|
|
|
/*fall through*/
|
|
|
|
case 'e': case 'E':
|
|
|
|
termios.c_cflag |= PARENB;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flow == 'r')
|
|
|
|
termios.c_cflag |= CRTSCTS;
|
|
|
|
|
2007-07-16 14:37:25 +08:00
|
|
|
/*
|
|
|
|
* some uarts on other side don't support no flow control.
|
|
|
|
* So we set * DTR in host uart to make them happy
|
|
|
|
*/
|
|
|
|
port->mctrl |= TIOCM_DTR;
|
|
|
|
|
2007-10-18 16:24:16 +08:00
|
|
|
port->ops->set_termios(port, &termios, &dummy);
|
2008-04-18 02:05:37 +08:00
|
|
|
/*
|
|
|
|
* Allow the setting of the UART parameters with a NULL console
|
|
|
|
* too:
|
|
|
|
*/
|
|
|
|
if (co)
|
|
|
|
co->cflag = termios.c_cflag;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
2008-04-18 02:05:37 +08:00
|
|
|
EXPORT_SYMBOL_GPL(uart_set_options);
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif /* CONFIG_SERIAL_CORE_CONSOLE */
|
|
|
|
|
2011-11-10 04:33:47 +08:00
|
|
|
/**
|
|
|
|
* uart_change_pm - set power state of the port
|
|
|
|
*
|
|
|
|
* @state: port descriptor
|
|
|
|
* @pm_state: new state
|
|
|
|
*
|
|
|
|
* Locking: port->mutex has to be held
|
|
|
|
*/
|
2012-12-07 18:36:08 +08:00
|
|
|
static void uart_change_pm(struct uart_state *state,
|
|
|
|
enum uart_pm_state pm_state)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-20 04:13:28 +08:00
|
|
|
struct uart_port *port = state->uart_port;
|
2006-05-16 18:28:49 +08:00
|
|
|
|
|
|
|
if (state->pm_state != pm_state) {
|
|
|
|
if (port->ops->pm)
|
|
|
|
port->ops->pm(port, pm_state, state->pm_state);
|
|
|
|
state->pm_state = pm_state;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
wake up from a serial port
Enable wakeup from serial ports, make it run-time configurable over sysfs,
e.g.,
echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup
Requires
# CONFIG_SYSFS_DEPRECATED is not set
Following suggestions from Alan and Russell moved the may_wake_up checks
to serial_core.c. This time actually tested - it does even work. Could
someone, please, verify, that put_device after device_find_child is
correct?
Also would be nice to test with a Natsemi UART, that can wake up the system,
if such systems exist.
For this you just have to apply the patch below, issue the above "echo"
command to one of your Natsemi port, suspend and resume your system, and
verify that your Natsemi port still works. If you are actually capable of
waking up the system from that port, would be nice to test that as well.
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 16:24:02 +08:00
|
|
|
struct uart_match {
|
|
|
|
struct uart_port *port;
|
|
|
|
struct uart_driver *driver;
|
|
|
|
};
|
|
|
|
|
|
|
|
static int serial_match_port(struct device *dev, void *data)
|
|
|
|
{
|
|
|
|
struct uart_match *match = data;
|
2008-07-05 00:59:28 +08:00
|
|
|
struct tty_driver *tty_drv = match->driver->tty_driver;
|
|
|
|
dev_t devt = MKDEV(tty_drv->major, tty_drv->minor_start) +
|
|
|
|
match->port->line;
|
wake up from a serial port
Enable wakeup from serial ports, make it run-time configurable over sysfs,
e.g.,
echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup
Requires
# CONFIG_SYSFS_DEPRECATED is not set
Following suggestions from Alan and Russell moved the may_wake_up checks
to serial_core.c. This time actually tested - it does even work. Could
someone, please, verify, that put_device after device_find_child is
correct?
Also would be nice to test with a Natsemi UART, that can wake up the system,
if such systems exist.
For this you just have to apply the patch below, issue the above "echo"
command to one of your Natsemi port, suspend and resume your system, and
verify that your Natsemi port still works. If you are actually capable of
waking up the system from that port, would be nice to test that as well.
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 16:24:02 +08:00
|
|
|
|
|
|
|
return dev->devt == devt; /* Actually, only one tty per port */
|
|
|
|
}
|
|
|
|
|
2009-09-20 04:13:30 +08:00
|
|
|
int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-20 04:13:30 +08:00
|
|
|
struct uart_state *state = drv->state + uport->line;
|
|
|
|
struct tty_port *port = &state->port;
|
wake up from a serial port
Enable wakeup from serial ports, make it run-time configurable over sysfs,
e.g.,
echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup
Requires
# CONFIG_SYSFS_DEPRECATED is not set
Following suggestions from Alan and Russell moved the may_wake_up checks
to serial_core.c. This time actually tested - it does even work. Could
someone, please, verify, that put_device after device_find_child is
correct?
Also would be nice to test with a Natsemi UART, that can wake up the system,
if such systems exist.
For this you just have to apply the patch below, issue the above "echo"
command to one of your Natsemi port, suspend and resume your system, and
verify that your Natsemi port still works. If you are actually capable of
waking up the system from that port, would be nice to test that as well.
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 16:24:02 +08:00
|
|
|
struct device *tty_dev;
|
2009-09-20 04:13:30 +08:00
|
|
|
struct uart_match match = {uport, drv};
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_lock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:30 +08:00
|
|
|
tty_dev = device_find_child(uport->dev, &match, serial_match_port);
|
wake up from a serial port
Enable wakeup from serial ports, make it run-time configurable over sysfs,
e.g.,
echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup
Requires
# CONFIG_SYSFS_DEPRECATED is not set
Following suggestions from Alan and Russell moved the may_wake_up checks
to serial_core.c. This time actually tested - it does even work. Could
someone, please, verify, that put_device after device_find_child is
correct?
Also would be nice to test with a Natsemi UART, that can wake up the system,
if such systems exist.
For this you just have to apply the patch below, issue the above "echo"
command to one of your Natsemi port, suspend and resume your system, and
verify that your Natsemi port still works. If you are actually capable of
waking up the system from that port, would be nice to test that as well.
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 16:24:02 +08:00
|
|
|
if (device_may_wakeup(tty_dev)) {
|
2010-12-16 20:42:47 +08:00
|
|
|
if (!enable_irq_wake(uport->irq))
|
|
|
|
uport->irq_wake = 1;
|
wake up from a serial port
Enable wakeup from serial ports, make it run-time configurable over sysfs,
e.g.,
echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup
Requires
# CONFIG_SYSFS_DEPRECATED is not set
Following suggestions from Alan and Russell moved the may_wake_up checks
to serial_core.c. This time actually tested - it does even work. Could
someone, please, verify, that put_device after device_find_child is
correct?
Also would be nice to test with a Natsemi UART, that can wake up the system,
if such systems exist.
For this you just have to apply the patch below, issue the above "echo"
command to one of your Natsemi port, suspend and resume your system, and
verify that your Natsemi port still works. If you are actually capable of
waking up the system from that port, would be nice to test that as well.
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 16:24:02 +08:00
|
|
|
put_device(tty_dev);
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
wake up from a serial port
Enable wakeup from serial ports, make it run-time configurable over sysfs,
e.g.,
echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup
Requires
# CONFIG_SYSFS_DEPRECATED is not set
Following suggestions from Alan and Russell moved the may_wake_up checks
to serial_core.c. This time actually tested - it does even work. Could
someone, please, verify, that put_device after device_find_child is
correct?
Also would be nice to test with a Natsemi UART, that can wake up the system,
if such systems exist.
For this you just have to apply the patch below, issue the above "echo"
command to one of your Natsemi port, suspend and resume your system, and
verify that your Natsemi port still works. If you are actually capable of
waking up the system from that port, would be nice to test that as well.
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 16:24:02 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2013-04-15 22:01:07 +08:00
|
|
|
put_device(tty_dev);
|
|
|
|
|
2009-12-02 23:20:56 +08:00
|
|
|
if (console_suspend_enabled || !uart_console(uport))
|
|
|
|
uport->suspended = 1;
|
wake up from a serial port
Enable wakeup from serial ports, make it run-time configurable over sysfs,
e.g.,
echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup
Requires
# CONFIG_SYSFS_DEPRECATED is not set
Following suggestions from Alan and Russell moved the may_wake_up checks
to serial_core.c. This time actually tested - it does even work. Could
someone, please, verify, that put_device after device_find_child is
correct?
Also would be nice to test with a Natsemi UART, that can wake up the system,
if such systems exist.
For this you just have to apply the patch below, issue the above "echo"
command to one of your Natsemi port, suspend and resume your system, and
verify that your Natsemi port still works. If you are actually capable of
waking up the system from that port, would be nice to test that as well.
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 16:24:02 +08:00
|
|
|
|
2009-09-20 04:13:30 +08:00
|
|
|
if (port->flags & ASYNC_INITIALIZED) {
|
|
|
|
const struct uart_ops *ops = uport->ops;
|
2008-02-05 14:27:52 +08:00
|
|
|
int tries;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-12-02 23:20:56 +08:00
|
|
|
if (console_suspend_enabled || !uart_console(uport)) {
|
|
|
|
set_bit(ASYNCB_SUSPENDED, &port->flags);
|
|
|
|
clear_bit(ASYNCB_INITIALIZED, &port->flags);
|
2006-10-02 00:17:40 +08:00
|
|
|
|
2009-12-02 23:20:56 +08:00
|
|
|
spin_lock_irq(&uport->lock);
|
|
|
|
ops->stop_tx(uport);
|
|
|
|
ops->set_mctrl(uport, 0);
|
|
|
|
ops->stop_rx(uport);
|
|
|
|
spin_unlock_irq(&uport->lock);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Wait for the transmitter to empty.
|
|
|
|
*/
|
2009-09-20 04:13:30 +08:00
|
|
|
for (tries = 3; !ops->tx_empty(uport) && tries; tries--)
|
2005-04-17 06:20:36 +08:00
|
|
|
msleep(10);
|
2008-02-05 14:27:52 +08:00
|
|
|
if (!tries)
|
2014-09-01 23:19:43 +08:00
|
|
|
dev_err(uport->dev, "%s%d: Unable to drain transmitter\n",
|
|
|
|
drv->dev_name,
|
|
|
|
drv->tty_driver->name_base + uport->line);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-12-02 23:20:56 +08:00
|
|
|
if (console_suspend_enabled || !uart_console(uport))
|
|
|
|
ops->shutdown(uport);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Disable the console device before suspending.
|
|
|
|
*/
|
2009-12-02 23:20:56 +08:00
|
|
|
if (console_suspend_enabled && uart_console(uport))
|
2009-09-20 04:13:30 +08:00
|
|
|
console_stop(uport->cons);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-12-02 23:20:56 +08:00
|
|
|
if (console_suspend_enabled || !uart_console(uport))
|
2012-12-07 18:36:08 +08:00
|
|
|
uart_change_pm(state, UART_PM_STATE_OFF);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-09-20 04:13:30 +08:00
|
|
|
int uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-20 04:13:30 +08:00
|
|
|
struct uart_state *state = drv->state + uport->line;
|
|
|
|
struct tty_port *port = &state->port;
|
2008-05-24 04:04:49 +08:00
|
|
|
struct device *tty_dev;
|
2009-09-20 04:13:30 +08:00
|
|
|
struct uart_match match = {uport, drv};
|
2009-09-20 04:13:33 +08:00
|
|
|
struct ktermios termios;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_lock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:30 +08:00
|
|
|
tty_dev = device_find_child(uport->dev, &match, serial_match_port);
|
|
|
|
if (!uport->suspended && device_may_wakeup(tty_dev)) {
|
2010-12-16 20:42:47 +08:00
|
|
|
if (uport->irq_wake) {
|
|
|
|
disable_irq_wake(uport->irq);
|
|
|
|
uport->irq_wake = 0;
|
|
|
|
}
|
2013-04-15 22:01:07 +08:00
|
|
|
put_device(tty_dev);
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
wake up from a serial port
Enable wakeup from serial ports, make it run-time configurable over sysfs,
e.g.,
echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup
Requires
# CONFIG_SYSFS_DEPRECATED is not set
Following suggestions from Alan and Russell moved the may_wake_up checks
to serial_core.c. This time actually tested - it does even work. Could
someone, please, verify, that put_device after device_find_child is
correct?
Also would be nice to test with a Natsemi UART, that can wake up the system,
if such systems exist.
For this you just have to apply the patch below, issue the above "echo"
command to one of your Natsemi port, suspend and resume your system, and
verify that your Natsemi port still works. If you are actually capable of
waking up the system from that port, would be nice to test that as well.
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 16:24:02 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2013-04-15 22:01:07 +08:00
|
|
|
put_device(tty_dev);
|
2009-09-20 04:13:30 +08:00
|
|
|
uport->suspended = 0;
|
wake up from a serial port
Enable wakeup from serial ports, make it run-time configurable over sysfs,
e.g.,
echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup
Requires
# CONFIG_SYSFS_DEPRECATED is not set
Following suggestions from Alan and Russell moved the may_wake_up checks
to serial_core.c. This time actually tested - it does even work. Could
someone, please, verify, that put_device after device_find_child is
correct?
Also would be nice to test with a Natsemi UART, that can wake up the system,
if such systems exist.
For this you just have to apply the patch below, issue the above "echo"
command to one of your Natsemi port, suspend and resume your system, and
verify that your Natsemi port still works. If you are actually capable of
waking up the system from that port, would be nice to test that as well.
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 16:24:02 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Re-enable the console device after suspending.
|
|
|
|
*/
|
serial-core: reset the console speed on resume
On some platforms, we need to restore the console speed on resume even
it was not suspended (no_console_suspend), and on others we don't have
to do that.
So don't care about the "console_suspend_enabled" and unconditionally
reset the console speed if it is a console.
This is actually a redo of ba15ab0 (Set proper console speed on resume
if console suspend is disabled) from Deepak Saxena. I also tried to
investigate more to find out if this change will break others, here is
what I've found out:
commit 891b9dd10764352926e1e107756aa229dfa2c210
Author: Jason Wang <jason77.wang@gmail.com>
serial-core: restore termios settings when resume console ports
commit ca2e71aa8cfb0056ce720f3fd53f59f5fac4a3e1
Author: Jason Wang <jason77.wang@gmail.com>
serial-core: skip call set_termios/console_start when no_console_suspend
commit 4547be7809a3b775ce750ec7f8b5748954741523
Author: Stanislav Brabec <sbrabec@suse.cz>
serial-core: resume serial hardware with no_console_suspend
commit ba15ab0e8de0d4439a91342ad52d55ca9e313f3d
Author: Deepak Saxena <dsaxena@laptop.org>
Set proper console speed on resume if console suspend is disabled
from ba15ab0, we learned that, even if the console suspend is disabled
(when no_console_suspend is set), we may still need to "reset the port
to the state it was in before we suspended."
Then with 4547be7, this piece of code is removed.
And then Jason Wang added that back in ca2e71a and 891b9dd, to fix
some breakage on OMAP3EVM platform. From ca2e71a we learned that the
"set_termios" things is actually needed by both console is suspended
and not suspended.
That's why I removed the console_suspended_enabled condition, and only
call console_start() when we actually suspeneded it.
I also noticed in this thread:
http://marc.info/?t=129079257100004&r=1&w=2, which talked about on
some platforms, UART HW will be cut power whether or not we set
no_console_suspend, and then on resume it does not work quite well. I
have a similar HW, and this patch fixed this issue, don't know if this
patch also works on their platforms.
[Update: Stanislav tested this patch on Zaurus and reported it improves the
situation. Thanks.]
CC: Greg KH <greg@kroah.com>
CC: Deepak Saxena <dsaxena@laptop.org>
CC: Jason Wang <jason77.wang@gmail.com>
CC: Stanislav Brabec <sbrabec@suse.cz>
CC: Daniel Drake <dsd@laptop.org>
Signed-off-by: Yin Kangkai <kangkai.yin@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-01-30 11:15:30 +08:00
|
|
|
if (uart_console(uport)) {
|
serial-core: restore termios settings when resume console ports
The commit 4547be7 rewrites suspend and resume functions. According
to this rewrite, when a serial port is a printk console device and
can suspend(without set no_console_suspend flag), it will definitely
call set_termios function during its resume, but parameter termios
isn't initialized, this will pass an unpredictable config to the
serial port. If this serial port is not a userspace opened tty device
, a suspend and resume action will make this serial port unusable.
I.E. ttyS0 is a printk console device, ttyS1 or keyboard+display is
userspace tty device, a suspend/resume action will make ttyS0
unusable.
If a serial port is both a printk console device and an opened tty
device, this issue can be overcome because it will call set_termios
again with the correct parameter in the uart_change_speed function.
Refer to the deleted content of commit 4547be7, revert parts relate
to restore settings into parameter termios. It is safe because if
a serial port is a printk console only device, the only meaningful
field in termios is c_cflag and its old config is saved in
uport->cons->cflag, if this port is also an opened tty device,
it will clear uport->cons->cflag in the uart_open and the old config
is saved in tty->termios.
Signed-off-by: Jason Wang <jason77.wang@gmail.com>
Acked-by: Stanislav Brabec <sbrabec@suse.cz>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2010-08-21 15:14:42 +08:00
|
|
|
/*
|
|
|
|
* First try to use the console cflag setting.
|
|
|
|
*/
|
|
|
|
memset(&termios, 0, sizeof(struct ktermios));
|
|
|
|
termios.c_cflag = uport->cons->cflag;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If that's unset, use the tty termios setting.
|
|
|
|
*/
|
2012-07-14 22:31:47 +08:00
|
|
|
if (port->tty && termios.c_cflag == 0)
|
|
|
|
termios = port->tty->termios;
|
serial-core: restore termios settings when resume console ports
The commit 4547be7 rewrites suspend and resume functions. According
to this rewrite, when a serial port is a printk console device and
can suspend(without set no_console_suspend flag), it will definitely
call set_termios function during its resume, but parameter termios
isn't initialized, this will pass an unpredictable config to the
serial port. If this serial port is not a userspace opened tty device
, a suspend and resume action will make this serial port unusable.
I.E. ttyS0 is a printk console device, ttyS1 or keyboard+display is
userspace tty device, a suspend/resume action will make ttyS0
unusable.
If a serial port is both a printk console device and an opened tty
device, this issue can be overcome because it will call set_termios
again with the correct parameter in the uart_change_speed function.
Refer to the deleted content of commit 4547be7, revert parts relate
to restore settings into parameter termios. It is safe because if
a serial port is a printk console only device, the only meaningful
field in termios is c_cflag and its old config is saved in
uport->cons->cflag, if this port is also an opened tty device,
it will clear uport->cons->cflag in the uart_open and the old config
is saved in tty->termios.
Signed-off-by: Jason Wang <jason77.wang@gmail.com>
Acked-by: Stanislav Brabec <sbrabec@suse.cz>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2010-08-21 15:14:42 +08:00
|
|
|
|
2011-09-05 16:28:18 +08:00
|
|
|
if (console_suspend_enabled)
|
2012-12-07 18:36:08 +08:00
|
|
|
uart_change_pm(state, UART_PM_STATE_ON);
|
2009-09-20 04:13:30 +08:00
|
|
|
uport->ops->set_termios(uport, &termios, NULL);
|
serial-core: reset the console speed on resume
On some platforms, we need to restore the console speed on resume even
it was not suspended (no_console_suspend), and on others we don't have
to do that.
So don't care about the "console_suspend_enabled" and unconditionally
reset the console speed if it is a console.
This is actually a redo of ba15ab0 (Set proper console speed on resume
if console suspend is disabled) from Deepak Saxena. I also tried to
investigate more to find out if this change will break others, here is
what I've found out:
commit 891b9dd10764352926e1e107756aa229dfa2c210
Author: Jason Wang <jason77.wang@gmail.com>
serial-core: restore termios settings when resume console ports
commit ca2e71aa8cfb0056ce720f3fd53f59f5fac4a3e1
Author: Jason Wang <jason77.wang@gmail.com>
serial-core: skip call set_termios/console_start when no_console_suspend
commit 4547be7809a3b775ce750ec7f8b5748954741523
Author: Stanislav Brabec <sbrabec@suse.cz>
serial-core: resume serial hardware with no_console_suspend
commit ba15ab0e8de0d4439a91342ad52d55ca9e313f3d
Author: Deepak Saxena <dsaxena@laptop.org>
Set proper console speed on resume if console suspend is disabled
from ba15ab0, we learned that, even if the console suspend is disabled
(when no_console_suspend is set), we may still need to "reset the port
to the state it was in before we suspended."
Then with 4547be7, this piece of code is removed.
And then Jason Wang added that back in ca2e71a and 891b9dd, to fix
some breakage on OMAP3EVM platform. From ca2e71a we learned that the
"set_termios" things is actually needed by both console is suspended
and not suspended.
That's why I removed the console_suspended_enabled condition, and only
call console_start() when we actually suspeneded it.
I also noticed in this thread:
http://marc.info/?t=129079257100004&r=1&w=2, which talked about on
some platforms, UART HW will be cut power whether or not we set
no_console_suspend, and then on resume it does not work quite well. I
have a similar HW, and this patch fixed this issue, don't know if this
patch also works on their platforms.
[Update: Stanislav tested this patch on Zaurus and reported it improves the
situation. Thanks.]
CC: Greg KH <greg@kroah.com>
CC: Deepak Saxena <dsaxena@laptop.org>
CC: Jason Wang <jason77.wang@gmail.com>
CC: Stanislav Brabec <sbrabec@suse.cz>
CC: Daniel Drake <dsd@laptop.org>
Signed-off-by: Yin Kangkai <kangkai.yin@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2011-01-30 11:15:30 +08:00
|
|
|
if (console_suspend_enabled)
|
|
|
|
console_start(uport->cons);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-09-20 04:13:30 +08:00
|
|
|
if (port->flags & ASYNC_SUSPENDED) {
|
|
|
|
const struct uart_ops *ops = uport->ops;
|
2005-11-13 23:28:51 +08:00
|
|
|
int ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-12-07 18:36:08 +08:00
|
|
|
uart_change_pm(state, UART_PM_STATE_ON);
|
2009-09-20 04:13:30 +08:00
|
|
|
spin_lock_irq(&uport->lock);
|
|
|
|
ops->set_mctrl(uport, 0);
|
|
|
|
spin_unlock_irq(&uport->lock);
|
2009-12-02 23:20:56 +08:00
|
|
|
if (console_suspend_enabled || !uart_console(uport)) {
|
2010-06-02 04:52:51 +08:00
|
|
|
/* Protected by port mutex for now */
|
|
|
|
struct tty_struct *tty = port->tty;
|
2009-12-02 23:20:56 +08:00
|
|
|
ret = ops->startup(uport);
|
|
|
|
if (ret == 0) {
|
2010-06-02 04:52:51 +08:00
|
|
|
if (tty)
|
|
|
|
uart_change_speed(tty, state, NULL);
|
2009-12-02 23:20:56 +08:00
|
|
|
spin_lock_irq(&uport->lock);
|
|
|
|
ops->set_mctrl(uport, uport->mctrl);
|
|
|
|
ops->start_tx(uport);
|
|
|
|
spin_unlock_irq(&uport->lock);
|
|
|
|
set_bit(ASYNCB_INITIALIZED, &port->flags);
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* Failed to resume - maybe hardware went away?
|
|
|
|
* Clear the "initialized" flag so we won't try
|
|
|
|
* to call the low level drivers shutdown method.
|
|
|
|
*/
|
2010-06-02 04:52:51 +08:00
|
|
|
uart_shutdown(tty, state);
|
2009-12-02 23:20:56 +08:00
|
|
|
}
|
2005-11-13 23:28:51 +08:00
|
|
|
}
|
2006-10-02 00:17:40 +08:00
|
|
|
|
2009-09-20 04:13:30 +08:00
|
|
|
clear_bit(ASYNCB_SUSPENDED, &port->flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
uart_report_port(struct uart_driver *drv, struct uart_port *port)
|
|
|
|
{
|
2005-09-03 22:30:21 +08:00
|
|
|
char address[64];
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
switch (port->iotype) {
|
|
|
|
case UPIO_PORT:
|
2008-10-13 17:35:42 +08:00
|
|
|
snprintf(address, sizeof(address), "I/O 0x%lx", port->iobase);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case UPIO_HUB6:
|
2005-09-03 22:30:21 +08:00
|
|
|
snprintf(address, sizeof(address),
|
2008-10-13 17:35:42 +08:00
|
|
|
"I/O 0x%lx offset 0x%x", port->iobase, port->hub6);
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
case UPIO_MEM:
|
|
|
|
case UPIO_MEM32:
|
2005-11-06 17:07:03 +08:00
|
|
|
case UPIO_AU:
|
2006-06-30 17:29:58 +08:00
|
|
|
case UPIO_TSI:
|
2005-09-03 22:30:21 +08:00
|
|
|
snprintf(address, sizeof(address),
|
2007-07-24 09:43:44 +08:00
|
|
|
"MMIO 0x%llx", (unsigned long long)port->mapbase);
|
2005-09-03 22:30:21 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
strlcpy(address, "*unknown*", sizeof(address));
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
}
|
2005-09-03 22:30:21 +08:00
|
|
|
|
2014-09-01 23:19:43 +08:00
|
|
|
dev_info(port->dev, "%s%d at %s (irq = %d, base_baud = %d) is a %s\n",
|
2008-10-13 17:45:26 +08:00
|
|
|
drv->dev_name,
|
|
|
|
drv->tty_driver->name_base + port->line,
|
2013-07-13 04:07:39 +08:00
|
|
|
address, port->irq, port->uartclk / 16, uart_type(port));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
uart_configure_port(struct uart_driver *drv, struct uart_state *state,
|
|
|
|
struct uart_port *port)
|
|
|
|
{
|
|
|
|
unsigned int flags;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* If there isn't a port here, don't do anything further.
|
|
|
|
*/
|
|
|
|
if (!port->iobase && !port->mapbase && !port->membase)
|
|
|
|
return;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Now do the auto configuration stuff. Note that config_port
|
|
|
|
* is expected to claim the resources and map the port for us.
|
|
|
|
*/
|
2009-01-02 21:49:54 +08:00
|
|
|
flags = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (port->flags & UPF_AUTO_IRQ)
|
|
|
|
flags |= UART_CONFIG_IRQ;
|
|
|
|
if (port->flags & UPF_BOOT_AUTOCONF) {
|
2009-01-02 21:49:54 +08:00
|
|
|
if (!(port->flags & UPF_FIXED_TYPE)) {
|
|
|
|
port->type = PORT_UNKNOWN;
|
|
|
|
flags |= UART_CONFIG_TYPE;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
port->ops->config_port(port, flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (port->type != PORT_UNKNOWN) {
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
uart_report_port(drv, port);
|
|
|
|
|
2007-02-14 16:33:06 +08:00
|
|
|
/* Power up port for set_mctrl() */
|
2012-12-07 18:36:08 +08:00
|
|
|
uart_change_pm(state, UART_PM_STATE_ON);
|
2007-02-14 16:33:06 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Ensure that the modem control lines are de-activated.
|
2008-02-05 14:27:46 +08:00
|
|
|
* keep the DTR setting that is set in uart_set_options()
|
2005-04-17 06:20:36 +08:00
|
|
|
* We probably don't need a spinlock around this, but
|
|
|
|
*/
|
|
|
|
spin_lock_irqsave(&port->lock, flags);
|
2008-02-05 14:27:46 +08:00
|
|
|
port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR);
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_unlock_irqrestore(&port->lock, flags);
|
|
|
|
|
2007-09-02 04:25:09 +08:00
|
|
|
/*
|
|
|
|
* If this driver supports console, and it hasn't been
|
|
|
|
* successfully registered yet, try to re-register it.
|
|
|
|
* It may be that the port was not available.
|
|
|
|
*/
|
|
|
|
if (port->cons && !(port->cons->flags & CON_ENABLED))
|
|
|
|
register_console(port->cons);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Power down all ports by default, except the
|
|
|
|
* console if we have one.
|
|
|
|
*/
|
|
|
|
if (!uart_console(port))
|
2012-12-07 18:36:08 +08:00
|
|
|
uart_change_pm(state, UART_PM_STATE_OFF);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-04-18 02:05:37 +08:00
|
|
|
#ifdef CONFIG_CONSOLE_POLL
|
|
|
|
|
|
|
|
static int uart_poll_init(struct tty_driver *driver, int line, char *options)
|
|
|
|
{
|
|
|
|
struct uart_driver *drv = driver->driver_state;
|
|
|
|
struct uart_state *state = drv->state + line;
|
|
|
|
struct uart_port *port;
|
|
|
|
int baud = 9600;
|
|
|
|
int bits = 8;
|
|
|
|
int parity = 'n';
|
|
|
|
int flow = 'n';
|
2012-09-25 05:27:53 +08:00
|
|
|
int ret;
|
2008-04-18 02:05:37 +08:00
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
if (!state || !state->uart_port)
|
2008-04-18 02:05:37 +08:00
|
|
|
return -1;
|
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
port = state->uart_port;
|
2008-04-18 02:05:37 +08:00
|
|
|
if (!(port->ops->poll_get_char && port->ops->poll_put_char))
|
|
|
|
return -1;
|
|
|
|
|
2012-09-25 05:27:53 +08:00
|
|
|
if (port->ops->poll_init) {
|
|
|
|
struct tty_port *tport = &state->port;
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
mutex_lock(&tport->mutex);
|
|
|
|
/*
|
|
|
|
* We don't set ASYNCB_INITIALIZED as we only initialized the
|
|
|
|
* hw, e.g. state->xmit is still uninitialized.
|
|
|
|
*/
|
|
|
|
if (!test_bit(ASYNCB_INITIALIZED, &tport->flags))
|
|
|
|
ret = port->ops->poll_init(port);
|
|
|
|
mutex_unlock(&tport->mutex);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-04-18 02:05:37 +08:00
|
|
|
if (options) {
|
|
|
|
uart_parse_options(options, &baud, &parity, &bits, &flow);
|
|
|
|
return uart_set_options(port, NULL, baud, parity, bits, flow);
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int uart_poll_get_char(struct tty_driver *driver, int line)
|
|
|
|
{
|
|
|
|
struct uart_driver *drv = driver->driver_state;
|
|
|
|
struct uart_state *state = drv->state + line;
|
|
|
|
struct uart_port *port;
|
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
if (!state || !state->uart_port)
|
2008-04-18 02:05:37 +08:00
|
|
|
return -1;
|
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
port = state->uart_port;
|
2008-04-18 02:05:37 +08:00
|
|
|
return port->ops->poll_get_char(port);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void uart_poll_put_char(struct tty_driver *driver, int line, char ch)
|
|
|
|
{
|
|
|
|
struct uart_driver *drv = driver->driver_state;
|
|
|
|
struct uart_state *state = drv->state + line;
|
|
|
|
struct uart_port *port;
|
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
if (!state || !state->uart_port)
|
2008-04-18 02:05:37 +08:00
|
|
|
return;
|
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
port = state->uart_port;
|
2014-04-22 01:06:43 +08:00
|
|
|
|
|
|
|
if (ch == '\n')
|
|
|
|
port->ops->poll_put_char(port, '\r');
|
2008-04-18 02:05:37 +08:00
|
|
|
port->ops->poll_put_char(port, ch);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-10-02 17:17:18 +08:00
|
|
|
static const struct tty_operations uart_ops = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.open = uart_open,
|
|
|
|
.close = uart_close,
|
|
|
|
.write = uart_write,
|
|
|
|
.put_char = uart_put_char,
|
|
|
|
.flush_chars = uart_flush_chars,
|
|
|
|
.write_room = uart_write_room,
|
|
|
|
.chars_in_buffer= uart_chars_in_buffer,
|
|
|
|
.flush_buffer = uart_flush_buffer,
|
|
|
|
.ioctl = uart_ioctl,
|
|
|
|
.throttle = uart_throttle,
|
|
|
|
.unthrottle = uart_unthrottle,
|
|
|
|
.send_xchar = uart_send_xchar,
|
|
|
|
.set_termios = uart_set_termios,
|
2008-06-03 22:18:54 +08:00
|
|
|
.set_ldisc = uart_set_ldisc,
|
2005-04-17 06:20:36 +08:00
|
|
|
.stop = uart_stop,
|
|
|
|
.start = uart_start,
|
|
|
|
.hangup = uart_hangup,
|
|
|
|
.break_ctl = uart_break_ctl,
|
|
|
|
.wait_until_sent= uart_wait_until_sent,
|
|
|
|
#ifdef CONFIG_PROC_FS
|
2009-04-01 06:19:21 +08:00
|
|
|
.proc_fops = &uart_proc_fops,
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
.tiocmget = uart_tiocmget,
|
|
|
|
.tiocmset = uart_tiocmset,
|
2010-09-17 01:21:24 +08:00
|
|
|
.get_icount = uart_get_icount,
|
2008-04-18 02:05:37 +08:00
|
|
|
#ifdef CONFIG_CONSOLE_POLL
|
|
|
|
.poll_init = uart_poll_init,
|
|
|
|
.poll_get_char = uart_poll_get_char,
|
|
|
|
.poll_put_char = uart_poll_put_char,
|
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
};
|
|
|
|
|
2010-06-02 04:52:58 +08:00
|
|
|
static const struct tty_port_operations uart_port_ops = {
|
2011-11-10 04:33:50 +08:00
|
|
|
.activate = uart_port_activate,
|
|
|
|
.shutdown = uart_port_shutdown,
|
2010-06-02 04:52:58 +08:00
|
|
|
.carrier_raised = uart_carrier_raised,
|
|
|
|
.dtr_rts = uart_dtr_rts,
|
|
|
|
};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* uart_register_driver - register a driver with the uart core layer
|
|
|
|
* @drv: low level driver structure
|
|
|
|
*
|
|
|
|
* Register a uart driver with the core driver. We in turn register
|
|
|
|
* with the tty layer, and initialise the core driver per-port state.
|
|
|
|
*
|
|
|
|
* We have a proc file in /proc/tty/driver which is named after the
|
|
|
|
* normal driver.
|
|
|
|
*
|
|
|
|
* drv->port should be NULL, and the per-port structures should be
|
|
|
|
* registered using uart_add_one_port after this call has succeeded.
|
|
|
|
*/
|
|
|
|
int uart_register_driver(struct uart_driver *drv)
|
|
|
|
{
|
2009-10-25 21:16:32 +08:00
|
|
|
struct tty_driver *normal;
|
2005-04-17 06:20:36 +08:00
|
|
|
int i, retval;
|
|
|
|
|
|
|
|
BUG_ON(drv->state);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Maybe we should be using a slab cache for this, especially if
|
|
|
|
* we have a large number of ports to handle.
|
|
|
|
*/
|
2007-02-14 16:33:07 +08:00
|
|
|
drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!drv->state)
|
|
|
|
goto out;
|
|
|
|
|
2009-10-25 21:16:32 +08:00
|
|
|
normal = alloc_tty_driver(drv->nr);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!normal)
|
2009-10-25 21:16:32 +08:00
|
|
|
goto out_kfree;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
drv->tty_driver = normal;
|
|
|
|
|
|
|
|
normal->driver_name = drv->driver_name;
|
|
|
|
normal->name = drv->dev_name;
|
|
|
|
normal->major = drv->major;
|
|
|
|
normal->minor_start = drv->minor;
|
|
|
|
normal->type = TTY_DRIVER_TYPE_SERIAL;
|
|
|
|
normal->subtype = SERIAL_TYPE_NORMAL;
|
|
|
|
normal->init_termios = tty_std_termios;
|
|
|
|
normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
|
2006-12-08 18:38:45 +08:00
|
|
|
normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
|
2005-06-21 12:15:16 +08:00
|
|
|
normal->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
|
2005-04-17 06:20:36 +08:00
|
|
|
normal->driver_state = drv;
|
|
|
|
tty_set_operations(normal, &uart_ops);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Initialise the UART state(s).
|
|
|
|
*/
|
|
|
|
for (i = 0; i < drv->nr; i++) {
|
|
|
|
struct uart_state *state = drv->state + i;
|
2009-09-20 04:13:31 +08:00
|
|
|
struct tty_port *port = &state->port;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
tty_port_init(port);
|
2010-06-02 04:52:58 +08:00
|
|
|
port->ops = &uart_port_ops;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
retval = tty_register_driver(normal);
|
2009-10-25 21:16:32 +08:00
|
|
|
if (retval >= 0)
|
|
|
|
return retval;
|
|
|
|
|
2012-11-15 16:49:56 +08:00
|
|
|
for (i = 0; i < drv->nr; i++)
|
|
|
|
tty_port_destroy(&drv->state[i].port);
|
2009-10-25 21:16:32 +08:00
|
|
|
put_tty_driver(normal);
|
|
|
|
out_kfree:
|
|
|
|
kfree(drv->state);
|
|
|
|
out:
|
|
|
|
return -ENOMEM;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* uart_unregister_driver - remove a driver from the uart core layer
|
|
|
|
* @drv: low level driver structure
|
|
|
|
*
|
|
|
|
* Remove all references to a driver from the core driver. The low
|
|
|
|
* level driver must have removed all its ports via the
|
|
|
|
* uart_remove_one_port() if it registered them with uart_add_one_port().
|
|
|
|
* (ie, drv->port == NULL)
|
|
|
|
*/
|
|
|
|
void uart_unregister_driver(struct uart_driver *drv)
|
|
|
|
{
|
|
|
|
struct tty_driver *p = drv->tty_driver;
|
2012-11-15 16:49:56 +08:00
|
|
|
unsigned int i;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
tty_unregister_driver(p);
|
|
|
|
put_tty_driver(p);
|
2012-11-15 16:49:56 +08:00
|
|
|
for (i = 0; i < drv->nr; i++)
|
|
|
|
tty_port_destroy(&drv->state[i].port);
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree(drv->state);
|
2012-05-14 21:51:22 +08:00
|
|
|
drv->state = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
drv->tty_driver = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
struct tty_driver *uart_console_device(struct console *co, int *index)
|
|
|
|
{
|
|
|
|
struct uart_driver *p = co->data;
|
|
|
|
*index = co->index;
|
|
|
|
return p->tty_driver;
|
|
|
|
}
|
|
|
|
|
2012-09-06 09:17:18 +08:00
|
|
|
static ssize_t uart_get_attr_uartclk(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
2012-10-29 23:19:57 +08:00
|
|
|
struct serial_struct tmp;
|
2012-09-06 09:17:18 +08:00
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
2012-10-29 23:20:25 +08:00
|
|
|
uart_get_info(port, &tmp);
|
2012-10-29 23:19:57 +08:00
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", tmp.baud_base * 16);
|
2012-09-06 09:17:18 +08:00
|
|
|
}
|
|
|
|
|
2012-10-29 23:20:40 +08:00
|
|
|
static ssize_t uart_get_attr_type(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", tmp.type);
|
|
|
|
}
|
|
|
|
static ssize_t uart_get_attr_line(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", tmp.line);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t uart_get_attr_port(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
2012-11-27 07:47:15 +08:00
|
|
|
unsigned long ioaddr;
|
2012-10-29 23:20:40 +08:00
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
2012-11-27 07:47:15 +08:00
|
|
|
ioaddr = tmp.port;
|
|
|
|
if (HIGH_BITS_OFFSET)
|
|
|
|
ioaddr |= (unsigned long)tmp.port_high << HIGH_BITS_OFFSET;
|
|
|
|
return snprintf(buf, PAGE_SIZE, "0x%lX\n", ioaddr);
|
2012-10-29 23:20:40 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t uart_get_attr_irq(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", tmp.irq);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t uart_get_attr_flags(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "0x%X\n", tmp.flags);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t uart_get_attr_xmit_fifo_size(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", tmp.xmit_fifo_size);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static ssize_t uart_get_attr_close_delay(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", tmp.close_delay);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static ssize_t uart_get_attr_closing_wait(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", tmp.closing_wait);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t uart_get_attr_custom_divisor(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", tmp.custom_divisor);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t uart_get_attr_io_type(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", tmp.io_type);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t uart_get_attr_iomem_base(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "0x%lX\n", (unsigned long)tmp.iomem_base);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t uart_get_attr_iomem_reg_shift(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
|
|
|
{
|
|
|
|
struct serial_struct tmp;
|
|
|
|
struct tty_port *port = dev_get_drvdata(dev);
|
|
|
|
|
|
|
|
uart_get_info(port, &tmp);
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%d\n", tmp.iomem_reg_shift);
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR(type, S_IRUSR | S_IRGRP, uart_get_attr_type, NULL);
|
|
|
|
static DEVICE_ATTR(line, S_IRUSR | S_IRGRP, uart_get_attr_line, NULL);
|
|
|
|
static DEVICE_ATTR(port, S_IRUSR | S_IRGRP, uart_get_attr_port, NULL);
|
|
|
|
static DEVICE_ATTR(irq, S_IRUSR | S_IRGRP, uart_get_attr_irq, NULL);
|
|
|
|
static DEVICE_ATTR(flags, S_IRUSR | S_IRGRP, uart_get_attr_flags, NULL);
|
|
|
|
static DEVICE_ATTR(xmit_fifo_size, S_IRUSR | S_IRGRP, uart_get_attr_xmit_fifo_size, NULL);
|
2012-09-06 09:17:18 +08:00
|
|
|
static DEVICE_ATTR(uartclk, S_IRUSR | S_IRGRP, uart_get_attr_uartclk, NULL);
|
2012-10-29 23:20:40 +08:00
|
|
|
static DEVICE_ATTR(close_delay, S_IRUSR | S_IRGRP, uart_get_attr_close_delay, NULL);
|
|
|
|
static DEVICE_ATTR(closing_wait, S_IRUSR | S_IRGRP, uart_get_attr_closing_wait, NULL);
|
|
|
|
static DEVICE_ATTR(custom_divisor, S_IRUSR | S_IRGRP, uart_get_attr_custom_divisor, NULL);
|
|
|
|
static DEVICE_ATTR(io_type, S_IRUSR | S_IRGRP, uart_get_attr_io_type, NULL);
|
|
|
|
static DEVICE_ATTR(iomem_base, S_IRUSR | S_IRGRP, uart_get_attr_iomem_base, NULL);
|
|
|
|
static DEVICE_ATTR(iomem_reg_shift, S_IRUSR | S_IRGRP, uart_get_attr_iomem_reg_shift, NULL);
|
2012-09-06 09:17:18 +08:00
|
|
|
|
|
|
|
static struct attribute *tty_dev_attrs[] = {
|
2012-10-29 23:20:40 +08:00
|
|
|
&dev_attr_type.attr,
|
|
|
|
&dev_attr_line.attr,
|
|
|
|
&dev_attr_port.attr,
|
|
|
|
&dev_attr_irq.attr,
|
|
|
|
&dev_attr_flags.attr,
|
|
|
|
&dev_attr_xmit_fifo_size.attr,
|
2012-09-06 09:17:18 +08:00
|
|
|
&dev_attr_uartclk.attr,
|
2012-10-29 23:20:40 +08:00
|
|
|
&dev_attr_close_delay.attr,
|
|
|
|
&dev_attr_closing_wait.attr,
|
|
|
|
&dev_attr_custom_divisor.attr,
|
|
|
|
&dev_attr_io_type.attr,
|
|
|
|
&dev_attr_iomem_base.attr,
|
|
|
|
&dev_attr_iomem_reg_shift.attr,
|
2012-09-06 09:17:18 +08:00
|
|
|
NULL,
|
|
|
|
};
|
|
|
|
|
2012-09-07 05:17:47 +08:00
|
|
|
static const struct attribute_group tty_dev_attr_group = {
|
2012-09-06 09:17:18 +08:00
|
|
|
.attrs = tty_dev_attrs,
|
|
|
|
};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/**
|
|
|
|
* uart_add_one_port - attach a driver-defined port structure
|
|
|
|
* @drv: pointer to the uart low level driver structure for this port
|
2009-09-22 02:12:03 +08:00
|
|
|
* @uport: uart port structure to use for this port.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* This allows the driver to register its own uart_port structure
|
|
|
|
* with the core driver. The main purpose is to allow the low
|
|
|
|
* level uart drivers to expand uart_port, rather than having yet
|
|
|
|
* more levels of structures.
|
|
|
|
*/
|
2009-09-20 04:13:31 +08:00
|
|
|
int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct uart_state *state;
|
2009-09-20 04:13:31 +08:00
|
|
|
struct tty_port *port;
|
2005-04-17 06:20:36 +08:00
|
|
|
int ret = 0;
|
wake up from a serial port
Enable wakeup from serial ports, make it run-time configurable over sysfs,
e.g.,
echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup
Requires
# CONFIG_SYSFS_DEPRECATED is not set
Following suggestions from Alan and Russell moved the may_wake_up checks
to serial_core.c. This time actually tested - it does even work. Could
someone, please, verify, that put_device after device_find_child is
correct?
Also would be nice to test with a Natsemi UART, that can wake up the system,
if such systems exist.
For this you just have to apply the patch below, issue the above "echo"
command to one of your Natsemi port, suspend and resume your system, and
verify that your Natsemi port still works. If you are actually capable of
waking up the system from that port, would be nice to test that as well.
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 16:24:02 +08:00
|
|
|
struct device *tty_dev;
|
2014-07-16 09:19:34 +08:00
|
|
|
int num_groups;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
BUG_ON(in_interrupt());
|
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
if (uport->line >= drv->nr)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
state = drv->state + uport->line;
|
|
|
|
port = &state->port;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-01-13 02:44:32 +08:00
|
|
|
mutex_lock(&port_mutex);
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_lock(&port->mutex);
|
2009-09-20 04:13:28 +08:00
|
|
|
if (state->uart_port) {
|
2005-04-17 06:20:36 +08:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2014-10-17 04:54:25 +08:00
|
|
|
/* Link the port to the driver state table and vice versa */
|
2009-09-20 04:13:31 +08:00
|
|
|
state->uart_port = uport;
|
2014-10-17 04:54:25 +08:00
|
|
|
uport->state = state;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-10-17 04:54:25 +08:00
|
|
|
state->pm_state = UART_PM_STATE_UNDEFINED;
|
2009-09-20 04:13:31 +08:00
|
|
|
uport->cons = drv->cons;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-07-04 04:05:45 +08:00
|
|
|
/*
|
|
|
|
* If this port is a console, then the spinlock is already
|
|
|
|
* initialised.
|
|
|
|
*/
|
2009-09-20 04:13:31 +08:00
|
|
|
if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) {
|
|
|
|
spin_lock_init(&uport->lock);
|
|
|
|
lockdep_set_class(&uport->lock, &port_lock_key);
|
2006-07-03 15:25:03 +08:00
|
|
|
}
|
2014-03-28 09:29:46 +08:00
|
|
|
if (uport->cons && uport->dev)
|
|
|
|
of_console_check(uport->dev->of_node, uport->cons->name, uport->line);
|
2005-07-04 04:05:45 +08:00
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
uart_configure_port(drv, state, uport);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-07-16 09:19:34 +08:00
|
|
|
num_groups = 2;
|
|
|
|
if (uport->attr_group)
|
|
|
|
num_groups++;
|
|
|
|
|
2014-07-23 14:06:22 +08:00
|
|
|
uport->tty_groups = kcalloc(num_groups, sizeof(*uport->tty_groups),
|
2014-07-16 09:19:34 +08:00
|
|
|
GFP_KERNEL);
|
|
|
|
if (!uport->tty_groups) {
|
|
|
|
ret = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
uport->tty_groups[0] = &tty_dev_attr_group;
|
|
|
|
if (uport->attr_group)
|
|
|
|
uport->tty_groups[1] = uport->attr_group;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* Register the port whether it's detected or not. This allows
|
2014-03-11 18:23:36 +08:00
|
|
|
* setserial to be used to alter this port's parameters.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2012-09-07 05:17:47 +08:00
|
|
|
tty_dev = tty_port_register_device_attr(port, drv->tty_driver,
|
2014-07-16 09:19:34 +08:00
|
|
|
uport->line, uport->dev, port, uport->tty_groups);
|
wake up from a serial port
Enable wakeup from serial ports, make it run-time configurable over sysfs,
e.g.,
echo enabled > /sys/devices/platform/serial8250.0/tty/ttyS0/power/wakeup
Requires
# CONFIG_SYSFS_DEPRECATED is not set
Following suggestions from Alan and Russell moved the may_wake_up checks
to serial_core.c. This time actually tested - it does even work. Could
someone, please, verify, that put_device after device_find_child is
correct?
Also would be nice to test with a Natsemi UART, that can wake up the system,
if such systems exist.
For this you just have to apply the patch below, issue the above "echo"
command to one of your Natsemi port, suspend and resume your system, and
verify that your Natsemi port still works. If you are actually capable of
waking up the system from that port, would be nice to test that as well.
Signed-off-by: Guennadi Liakhovetski <g.liakhovetski@gmx.de>
Cc: Alan Cox <alan@lxorguk.ukuu.org.uk>
Cc: Russell King <rmk@arm.linux.org.uk>
Cc: Kay Sievers <kay.sievers@vrfy.org>
Cc: Greg KH <greg@kroah.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2007-10-16 16:24:02 +08:00
|
|
|
if (likely(!IS_ERR(tty_dev))) {
|
2012-01-20 03:28:56 +08:00
|
|
|
device_set_wakeup_capable(tty_dev, 1);
|
|
|
|
} else {
|
2014-09-01 23:19:43 +08:00
|
|
|
dev_err(uport->dev, "Cannot register tty device on line %d\n",
|
2009-09-20 04:13:31 +08:00
|
|
|
uport->line);
|
2012-01-20 03:28:56 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-04-30 18:13:50 +08:00
|
|
|
/*
|
|
|
|
* Ensure UPF_DEAD is not set.
|
|
|
|
*/
|
2009-09-20 04:13:31 +08:00
|
|
|
uport->flags &= ~UPF_DEAD;
|
2006-04-30 18:13:50 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
out:
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_unlock(&port->mutex);
|
2006-01-13 02:44:32 +08:00
|
|
|
mutex_unlock(&port_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* uart_remove_one_port - detach a driver defined port structure
|
|
|
|
* @drv: pointer to the uart low level driver structure for this port
|
2009-09-22 02:12:03 +08:00
|
|
|
* @uport: uart port structure for this port
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
|
|
|
* This unhooks (and hangs up) the specified port structure from the
|
|
|
|
* core driver. No further calls will be made to the low-level code
|
|
|
|
* for this port.
|
|
|
|
*/
|
2009-09-20 04:13:31 +08:00
|
|
|
int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-09-20 04:13:31 +08:00
|
|
|
struct uart_state *state = drv->state + uport->line;
|
|
|
|
struct tty_port *port = &state->port;
|
2014-03-17 21:10:58 +08:00
|
|
|
struct tty_struct *tty;
|
2012-12-27 15:51:31 +08:00
|
|
|
int ret = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
BUG_ON(in_interrupt());
|
|
|
|
|
2009-09-20 04:13:31 +08:00
|
|
|
if (state->uart_port != uport)
|
2014-09-01 23:19:43 +08:00
|
|
|
dev_alert(uport->dev, "Removing wrong port: %p != %p\n",
|
2009-09-20 04:13:31 +08:00
|
|
|
state->uart_port, uport);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-01-13 02:44:32 +08:00
|
|
|
mutex_lock(&port_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-04-30 18:13:50 +08:00
|
|
|
/*
|
|
|
|
* Mark the port "dead" - this prevents any opens from
|
|
|
|
* succeeding while we shut down the port.
|
|
|
|
*/
|
2009-09-20 04:13:31 +08:00
|
|
|
mutex_lock(&port->mutex);
|
2012-12-27 15:51:31 +08:00
|
|
|
if (!state->uart_port) {
|
|
|
|
mutex_unlock(&port->mutex);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2009-09-20 04:13:31 +08:00
|
|
|
uport->flags |= UPF_DEAD;
|
|
|
|
mutex_unlock(&port->mutex);
|
2006-04-30 18:13:50 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
2005-06-21 12:15:16 +08:00
|
|
|
* Remove the devices from the tty layer
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2009-09-20 04:13:31 +08:00
|
|
|
tty_unregister_device(drv->tty_driver, uport->line);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2014-03-17 21:10:58 +08:00
|
|
|
tty = tty_port_tty_get(port);
|
|
|
|
if (tty) {
|
2009-09-20 04:13:31 +08:00
|
|
|
tty_vhangup(port->tty);
|
2014-03-17 21:10:58 +08:00
|
|
|
tty_kref_put(tty);
|
|
|
|
}
|
2006-04-30 18:13:50 +08:00
|
|
|
|
2014-02-28 21:21:32 +08:00
|
|
|
/*
|
|
|
|
* If the port is used as a console, unregister it
|
|
|
|
*/
|
|
|
|
if (uart_console(uport))
|
|
|
|
unregister_console(uport->cons);
|
|
|
|
|
2006-04-30 18:13:50 +08:00
|
|
|
/*
|
|
|
|
* Free the port IO and memory resources, if any.
|
|
|
|
*/
|
2009-09-20 04:13:31 +08:00
|
|
|
if (uport->type != PORT_UNKNOWN)
|
|
|
|
uport->ops->release_port(uport);
|
2014-07-16 09:19:34 +08:00
|
|
|
kfree(uport->tty_groups);
|
2006-04-30 18:13:50 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Indicate that there isn't a port here anymore.
|
|
|
|
*/
|
2009-09-20 04:13:31 +08:00
|
|
|
uport->type = PORT_UNKNOWN;
|
2006-04-30 18:13:50 +08:00
|
|
|
|
2009-09-20 04:13:28 +08:00
|
|
|
state->uart_port = NULL;
|
2012-12-27 15:51:31 +08:00
|
|
|
out:
|
2006-01-13 02:44:32 +08:00
|
|
|
mutex_unlock(&port_mutex);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-12-27 15:51:31 +08:00
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Are the two ports equivalent?
|
|
|
|
*/
|
|
|
|
int uart_match_port(struct uart_port *port1, struct uart_port *port2)
|
|
|
|
{
|
|
|
|
if (port1->iotype != port2->iotype)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
switch (port1->iotype) {
|
|
|
|
case UPIO_PORT:
|
|
|
|
return (port1->iobase == port2->iobase);
|
|
|
|
case UPIO_HUB6:
|
|
|
|
return (port1->iobase == port2->iobase) &&
|
|
|
|
(port1->hub6 == port2->hub6);
|
|
|
|
case UPIO_MEM:
|
2006-08-28 23:49:03 +08:00
|
|
|
case UPIO_MEM32:
|
|
|
|
case UPIO_AU:
|
|
|
|
case UPIO_TSI:
|
2006-01-05 02:09:44 +08:00
|
|
|
return (port1->mapbase == port2->mapbase);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(uart_match_port);
|
|
|
|
|
2011-11-10 04:33:43 +08:00
|
|
|
/**
|
|
|
|
* uart_handle_dcd_change - handle a change of carrier detect state
|
|
|
|
* @uport: uart_port structure for the open port
|
|
|
|
* @status: new carrier detect status, nonzero if active
|
2014-09-11 03:06:23 +08:00
|
|
|
*
|
|
|
|
* Caller must hold uport->lock
|
2011-11-10 04:33:43 +08:00
|
|
|
*/
|
|
|
|
void uart_handle_dcd_change(struct uart_port *uport, unsigned int status)
|
|
|
|
{
|
2013-02-10 17:44:30 +08:00
|
|
|
struct tty_port *port = &uport->state->port;
|
2012-09-19 22:35:46 +08:00
|
|
|
struct tty_struct *tty = port->tty;
|
2014-09-03 05:39:21 +08:00
|
|
|
struct tty_ldisc *ld;
|
2011-11-10 04:33:43 +08:00
|
|
|
|
2014-09-11 03:06:23 +08:00
|
|
|
lockdep_assert_held_once(&uport->lock);
|
|
|
|
|
2014-09-03 05:39:21 +08:00
|
|
|
if (tty) {
|
|
|
|
ld = tty_ldisc_ref(tty);
|
|
|
|
if (ld) {
|
|
|
|
if (ld->ops->dcd_change)
|
|
|
|
ld->ops->dcd_change(tty, status);
|
|
|
|
tty_ldisc_deref(ld);
|
|
|
|
}
|
2013-02-10 17:44:30 +08:00
|
|
|
}
|
2011-11-10 04:33:43 +08:00
|
|
|
|
|
|
|
uport->icount.dcd++;
|
|
|
|
|
2014-09-11 03:06:24 +08:00
|
|
|
if (uart_dcd_enabled(uport)) {
|
2011-11-10 04:33:43 +08:00
|
|
|
if (status)
|
|
|
|
wake_up_interruptible(&port->open_wait);
|
2012-09-19 22:35:46 +08:00
|
|
|
else if (tty)
|
|
|
|
tty_hangup(tty);
|
2011-11-10 04:33:43 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(uart_handle_dcd_change);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* uart_handle_cts_change - handle a change of clear-to-send state
|
|
|
|
* @uport: uart_port structure for the open port
|
|
|
|
* @status: new clear to send status, nonzero if active
|
2014-09-11 03:06:23 +08:00
|
|
|
*
|
|
|
|
* Caller must hold uport->lock
|
2011-11-10 04:33:43 +08:00
|
|
|
*/
|
|
|
|
void uart_handle_cts_change(struct uart_port *uport, unsigned int status)
|
|
|
|
{
|
2014-09-11 03:06:23 +08:00
|
|
|
lockdep_assert_held_once(&uport->lock);
|
|
|
|
|
2011-11-10 04:33:43 +08:00
|
|
|
uport->icount.cts++;
|
|
|
|
|
2014-09-11 03:06:24 +08:00
|
|
|
if (uart_cts_enabled(uport)) {
|
2014-09-11 03:06:26 +08:00
|
|
|
if (uport->hw_stopped) {
|
2011-11-10 04:33:43 +08:00
|
|
|
if (status) {
|
2014-09-11 03:06:26 +08:00
|
|
|
uport->hw_stopped = 0;
|
2011-11-10 04:33:43 +08:00
|
|
|
uport->ops->start_tx(uport);
|
|
|
|
uart_write_wakeup(uport);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (!status) {
|
2014-09-11 03:06:26 +08:00
|
|
|
uport->hw_stopped = 1;
|
2011-11-10 04:33:43 +08:00
|
|
|
uport->ops->stop_tx(uport);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(uart_handle_cts_change);
|
|
|
|
|
2011-11-10 04:33:47 +08:00
|
|
|
/**
|
|
|
|
* uart_insert_char - push a char to the uart layer
|
|
|
|
*
|
|
|
|
* User is responsible to call tty_flip_buffer_push when they are done with
|
|
|
|
* insertion.
|
|
|
|
*
|
|
|
|
* @port: corresponding port
|
|
|
|
* @status: state of the serial port RX buffer (LSR for 8250)
|
|
|
|
* @overrun: mask of overrun bits in @status
|
|
|
|
* @ch: character to push
|
|
|
|
* @flag: flag for the character (see TTY_NORMAL and friends)
|
|
|
|
*/
|
2011-11-10 04:33:43 +08:00
|
|
|
void uart_insert_char(struct uart_port *port, unsigned int status,
|
|
|
|
unsigned int overrun, unsigned int ch, unsigned int flag)
|
|
|
|
{
|
2013-01-03 22:53:03 +08:00
|
|
|
struct tty_port *tport = &port->state->port;
|
2011-11-10 04:33:43 +08:00
|
|
|
|
|
|
|
if ((status & port->ignore_status_mask & ~overrun) == 0)
|
2013-01-03 22:53:03 +08:00
|
|
|
if (tty_insert_flip_char(tport, ch, flag) == 0)
|
2012-05-23 22:37:31 +08:00
|
|
|
++port->icount.buf_overrun;
|
2011-11-10 04:33:43 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Overrun is special. Since it's reported immediately,
|
|
|
|
* it doesn't affect the current character.
|
|
|
|
*/
|
|
|
|
if (status & ~port->ignore_status_mask & overrun)
|
2013-01-03 22:53:03 +08:00
|
|
|
if (tty_insert_flip_char(tport, 0, TTY_OVERRUN) == 0)
|
2012-05-23 22:37:31 +08:00
|
|
|
++port->icount.buf_overrun;
|
2011-11-10 04:33:43 +08:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(uart_insert_char);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
EXPORT_SYMBOL(uart_write_wakeup);
|
|
|
|
EXPORT_SYMBOL(uart_register_driver);
|
|
|
|
EXPORT_SYMBOL(uart_unregister_driver);
|
|
|
|
EXPORT_SYMBOL(uart_suspend_port);
|
|
|
|
EXPORT_SYMBOL(uart_resume_port);
|
|
|
|
EXPORT_SYMBOL(uart_add_one_port);
|
|
|
|
EXPORT_SYMBOL(uart_remove_one_port);
|
|
|
|
|
|
|
|
MODULE_DESCRIPTION("Serial driver core");
|
|
|
|
MODULE_LICENSE("GPL");
|