2019-05-27 06:55:05 +00:00
|
|
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* linux/drivers/char/serial_core.h
|
|
|
|
*
|
|
|
|
* Copyright (C) 2000 Deep Blue Solutions Ltd.
|
|
|
|
*/
|
|
|
|
#ifndef LINUX_SERIAL_CORE_H
|
|
|
|
#define LINUX_SERIAL_CORE_H
|
|
|
|
|
2017-07-25 17:39:58 +00:00
|
|
|
#include <linux/bitops.h>
|
2005-07-16 08:30:53 +00:00
|
|
|
#include <linux/compiler.h>
|
2018-10-30 22:11:06 +00:00
|
|
|
#include <linux/console.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <linux/interrupt.h>
|
|
|
|
#include <linux/circ_buf.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/sched.h>
|
|
|
|
#include <linux/tty.h>
|
2006-01-13 21:37:07 +00:00
|
|
|
#include <linux/mutex.h>
|
2007-06-01 07:47:07 +00:00
|
|
|
#include <linux/sysrq.h>
|
2012-10-13 09:46:48 +00:00
|
|
|
#include <uapi/linux/serial_core.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2013-05-15 15:35:37 +00:00
|
|
|
#ifdef CONFIG_SERIAL_CORE_CONSOLE
|
|
|
|
#define uart_console(port) \
|
|
|
|
((port)->cons && (port)->cons->index == (port)->line)
|
|
|
|
#else
|
2015-04-11 15:02:36 +00:00
|
|
|
#define uart_console(port) ({ (void)port; 0; })
|
2013-05-15 15:35:37 +00:00
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct uart_port;
|
|
|
|
struct serial_struct;
|
|
|
|
struct device;
|
|
|
|
|
|
|
|
/*
|
2012-12-27 04:43:42 +00:00
|
|
|
* This structure describes all the operations that can be done on the
|
2019-06-27 19:31:35 +00:00
|
|
|
* physical hardware. See Documentation/driver-api/serial/driver.rst for details.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
|
|
|
struct uart_ops {
|
|
|
|
unsigned int (*tx_empty)(struct uart_port *);
|
|
|
|
void (*set_mctrl)(struct uart_port *, unsigned int mctrl);
|
|
|
|
unsigned int (*get_mctrl)(struct uart_port *);
|
2005-08-31 09:12:14 +00:00
|
|
|
void (*stop_tx)(struct uart_port *);
|
|
|
|
void (*start_tx)(struct uart_port *);
|
2012-04-17 16:23:14 +00:00
|
|
|
void (*throttle)(struct uart_port *);
|
|
|
|
void (*unthrottle)(struct uart_port *);
|
2005-04-16 22:20:36 +00:00
|
|
|
void (*send_xchar)(struct uart_port *, char ch);
|
|
|
|
void (*stop_rx)(struct uart_port *);
|
|
|
|
void (*enable_ms)(struct uart_port *);
|
|
|
|
void (*break_ctl)(struct uart_port *, int ctl);
|
|
|
|
int (*startup)(struct uart_port *);
|
|
|
|
void (*shutdown)(struct uart_port *);
|
2008-07-16 20:52:36 +00:00
|
|
|
void (*flush_buffer)(struct uart_port *);
|
2006-12-08 10:38:45 +00:00
|
|
|
void (*set_termios)(struct uart_port *, struct ktermios *new,
|
|
|
|
struct ktermios *old);
|
2014-11-05 18:11:43 +00:00
|
|
|
void (*set_ldisc)(struct uart_port *, struct ktermios *);
|
2005-04-16 22:20:36 +00:00
|
|
|
void (*pm)(struct uart_port *, unsigned int state,
|
|
|
|
unsigned int oldstate);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Return a string describing the type of the port
|
|
|
|
*/
|
2012-12-27 04:43:42 +00:00
|
|
|
const char *(*type)(struct uart_port *);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Release IO and memory resources used by the port.
|
|
|
|
* This includes iounmap if necessary.
|
|
|
|
*/
|
|
|
|
void (*release_port)(struct uart_port *);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Request IO and memory resources used by the port.
|
|
|
|
* This includes iomapping the port if necessary.
|
|
|
|
*/
|
|
|
|
int (*request_port)(struct uart_port *);
|
|
|
|
void (*config_port)(struct uart_port *, int);
|
|
|
|
int (*verify_port)(struct uart_port *, struct serial_struct *);
|
|
|
|
int (*ioctl)(struct uart_port *, unsigned int, unsigned long);
|
2008-04-17 18:05:37 +00:00
|
|
|
#ifdef CONFIG_CONSOLE_POLL
|
2012-09-24 21:27:53 +00:00
|
|
|
int (*poll_init)(struct uart_port *);
|
2012-12-27 04:43:42 +00:00
|
|
|
void (*poll_put_char)(struct uart_port *, unsigned char);
|
2008-04-17 18:05:37 +00:00
|
|
|
int (*poll_get_char)(struct uart_port *);
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2010-05-21 02:04:22 +00:00
|
|
|
#define NO_POLL_CHAR 0x00ff0000
|
2005-04-16 22:20:36 +00:00
|
|
|
#define UART_CONFIG_TYPE (1 << 0)
|
|
|
|
#define UART_CONFIG_IRQ (1 << 1)
|
|
|
|
|
|
|
|
struct uart_icount {
|
|
|
|
__u32 cts;
|
|
|
|
__u32 dsr;
|
|
|
|
__u32 rng;
|
|
|
|
__u32 dcd;
|
|
|
|
__u32 rx;
|
|
|
|
__u32 tx;
|
|
|
|
__u32 frame;
|
|
|
|
__u32 overrun;
|
|
|
|
__u32 parity;
|
|
|
|
__u32 brk;
|
|
|
|
__u32 buf_overrun;
|
|
|
|
};
|
|
|
|
|
2016-12-11 04:34:53 +00:00
|
|
|
typedef unsigned int __bitwise upf_t;
|
|
|
|
typedef unsigned int __bitwise upstat_t;
|
2006-01-21 23:03:28 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct uart_port {
|
|
|
|
spinlock_t lock; /* port lock */
|
2008-10-13 09:35:23 +00:00
|
|
|
unsigned long iobase; /* in/out[bwl] */
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char __iomem *membase; /* read/write[bwl] */
|
2009-01-02 13:49:47 +00:00
|
|
|
unsigned int (*serial_in)(struct uart_port *, int);
|
|
|
|
void (*serial_out)(struct uart_port *, int, int);
|
U6715 16550A serial driver support
UART Features extract from STEricsson U6715 data-sheet (arm926 SoC for mobile phone):
* Fully compatible with industry standard 16C550 and 16C450 from various
manufacturers
* RX and TX 64 byte FIFO reduces CPU interrupts
* Full double buffering
* Modem control signals include CTS, RTS, (and DSR, DTR on UART1 only)
* Automatic baud rate selection
* Manual or automatic RTS/CTS smart hardware flow control
* Programmable serial characteristics:
– Baud rate generation (50 to 3.25M baud)
– 5, 6, 7 or 8-bit characters
– Even, odd or no-parity bit generation and detection
– 1, 1.5 or 2 stop bit generation
* Independent control of transmit, receive, line status, data set interrupts and FIFOs
* Full status-reporting capabilities
* Separate DMA signaling for RX and TX
* Timed interrupt to spread receive interrupt on known duration
* DMA time-out interrupt to allow detection of end of reception
* Carkit pulse coding and decoding compliant with USB carkit control interface [40]
In 16550A auto-configuration, if the fifo size is 64 then it's an U6 16550A port
Add set_termios hook & export serial8250_do_set_termios to change uart
clock following baudrate
Signed-off-by: Philippe Langlais <philippe.langlais@stericsson.com>
Acked-by: Alan Cox <alan@linux.intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
2010-07-29 15:13:57 +00:00
|
|
|
void (*set_termios)(struct uart_port *,
|
|
|
|
struct ktermios *new,
|
|
|
|
struct ktermios *old);
|
2016-11-10 18:07:55 +00:00
|
|
|
void (*set_ldisc)(struct uart_port *,
|
|
|
|
struct ktermios *);
|
2016-04-06 04:06:51 +00:00
|
|
|
unsigned int (*get_mctrl)(struct uart_port *);
|
2014-12-31 01:28:15 +00:00
|
|
|
void (*set_mctrl)(struct uart_port *, unsigned int);
|
2018-07-12 01:57:00 +00:00
|
|
|
unsigned int (*get_divisor)(struct uart_port *,
|
|
|
|
unsigned int baud,
|
|
|
|
unsigned int *frac);
|
|
|
|
void (*set_divisor)(struct uart_port *,
|
|
|
|
unsigned int baud,
|
|
|
|
unsigned int quot,
|
|
|
|
unsigned int quot_frac);
|
2014-09-05 19:02:37 +00:00
|
|
|
int (*startup)(struct uart_port *port);
|
|
|
|
void (*shutdown)(struct uart_port *port);
|
2014-09-10 19:29:56 +00:00
|
|
|
void (*throttle)(struct uart_port *port);
|
|
|
|
void (*unthrottle)(struct uart_port *port);
|
2011-08-15 09:17:51 +00:00
|
|
|
int (*handle_irq)(struct uart_port *);
|
2010-09-25 13:13:45 +00:00
|
|
|
void (*pm)(struct uart_port *, unsigned int state,
|
|
|
|
unsigned int old);
|
2012-04-10 21:10:53 +00:00
|
|
|
void (*handle_break)(struct uart_port *);
|
2014-11-06 21:46:13 +00:00
|
|
|
int (*rs485_config)(struct uart_port *,
|
|
|
|
struct serial_rs485 *rs485);
|
2018-09-26 12:58:47 +00:00
|
|
|
int (*iso7816_config)(struct uart_port *,
|
|
|
|
struct serial_iso7816 *iso7816);
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int irq; /* irq number */
|
2009-09-19 20:13:19 +00:00
|
|
|
unsigned long irqflags; /* irq flags */
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int uartclk; /* base uart clock */
|
2006-07-02 19:45:51 +00:00
|
|
|
unsigned int fifosize; /* tx fifo size */
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned char x_char; /* xon/xoff char */
|
|
|
|
unsigned char regshift; /* reg offset shift */
|
|
|
|
unsigned char iotype; /* io access style */
|
2017-07-25 17:39:58 +00:00
|
|
|
unsigned char quirks; /* internal quirks */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2015-03-01 15:24:28 +00:00
|
|
|
#define UPIO_PORT (SERIAL_IO_PORT) /* 8b I/O port access */
|
|
|
|
#define UPIO_HUB6 (SERIAL_IO_HUB6) /* Hub6 ISA card */
|
2015-11-28 02:29:24 +00:00
|
|
|
#define UPIO_MEM (SERIAL_IO_MEM) /* driver-specific */
|
2015-03-01 15:24:28 +00:00
|
|
|
#define UPIO_MEM32 (SERIAL_IO_MEM32) /* 32b little endian */
|
|
|
|
#define UPIO_AU (SERIAL_IO_AU) /* Au1x00 and RT288x type IO */
|
|
|
|
#define UPIO_TSI (SERIAL_IO_TSI) /* Tsi108/109 type IO */
|
|
|
|
#define UPIO_MEM32BE (SERIAL_IO_MEM32BE) /* 32b big endian */
|
2015-10-28 03:46:05 +00:00
|
|
|
#define UPIO_MEM16 (SERIAL_IO_MEM16) /* 16b little endian */
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2017-07-25 17:39:58 +00:00
|
|
|
/* quirks must be updated while holding port mutex */
|
|
|
|
#define UPQ_NO_TXEN_TEST BIT(0)
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int read_status_mask; /* driver specific */
|
|
|
|
unsigned int ignore_status_mask; /* driver specific */
|
2009-09-19 20:13:28 +00:00
|
|
|
struct uart_state *state; /* pointer to parent state */
|
2005-04-16 22:20:36 +00:00
|
|
|
struct uart_icount icount; /* statistics */
|
|
|
|
|
|
|
|
struct console *cons; /* struct console, if any */
|
2009-04-06 16:34:34 +00:00
|
|
|
#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(SUPPORT_SYSRQ)
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long sysrq; /* sysrq timeout */
|
2018-10-30 22:11:04 +00:00
|
|
|
unsigned int sysrq_ch; /* char for sysrq */
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
2014-09-02 21:39:19 +00:00
|
|
|
/* flags must be updated while holding port mutex */
|
2006-01-21 23:03:28 +00:00
|
|
|
upf_t flags;
|
|
|
|
|
2014-10-16 20:54:21 +00:00
|
|
|
/*
|
|
|
|
* These flags must be equivalent to the flags defined in
|
|
|
|
* include/uapi/linux/tty_flags.h which are the userspace definitions
|
|
|
|
* assigned from the serial_struct flags in uart_set_info()
|
|
|
|
* [for bit definitions in the UPF_CHANGE_MASK]
|
|
|
|
*
|
|
|
|
* Bits [0..UPF_LAST_USER] are userspace defined/visible/changeable
|
|
|
|
* The remaining bits are serial-core specific and not modifiable by
|
|
|
|
* userspace.
|
|
|
|
*/
|
|
|
|
#define UPF_FOURPORT ((__force upf_t) ASYNC_FOURPORT /* 1 */ )
|
|
|
|
#define UPF_SAK ((__force upf_t) ASYNC_SAK /* 2 */ )
|
|
|
|
#define UPF_SPD_HI ((__force upf_t) ASYNC_SPD_HI /* 4 */ )
|
|
|
|
#define UPF_SPD_VHI ((__force upf_t) ASYNC_SPD_VHI /* 5 */ )
|
|
|
|
#define UPF_SPD_CUST ((__force upf_t) ASYNC_SPD_CUST /* 0x0030 */ )
|
|
|
|
#define UPF_SPD_WARP ((__force upf_t) ASYNC_SPD_WARP /* 0x1010 */ )
|
|
|
|
#define UPF_SPD_MASK ((__force upf_t) ASYNC_SPD_MASK /* 0x1030 */ )
|
|
|
|
#define UPF_SKIP_TEST ((__force upf_t) ASYNC_SKIP_TEST /* 6 */ )
|
|
|
|
#define UPF_AUTO_IRQ ((__force upf_t) ASYNC_AUTO_IRQ /* 7 */ )
|
|
|
|
#define UPF_HARDPPS_CD ((__force upf_t) ASYNC_HARDPPS_CD /* 11 */ )
|
|
|
|
#define UPF_SPD_SHI ((__force upf_t) ASYNC_SPD_SHI /* 12 */ )
|
|
|
|
#define UPF_LOW_LATENCY ((__force upf_t) ASYNC_LOW_LATENCY /* 13 */ )
|
|
|
|
#define UPF_BUGGY_UART ((__force upf_t) ASYNC_BUGGY_UART /* 14 */ )
|
|
|
|
#define UPF_MAGIC_MULTIPLIER ((__force upf_t) ASYNC_MAGIC_MULTIPLIER /* 16 */ )
|
|
|
|
|
2017-05-02 07:45:42 +00:00
|
|
|
#define UPF_NO_THRE_TEST ((__force upf_t) (1 << 19))
|
serial: core: Rework hw-assisted flow control support
hw-assisted flow control support was added to the serial core
in v3.8 with commits,
dba05832cbe4f ("SERIAL: core: add hardware assisted h/w flow control support")
2cbacafd7af0f ("SERIAL: core: add hardware assisted s/w flow control support")
9aba8d5b01119 ("SERIAL: core: add throttle/unthrottle callbacks for hardware
assisted flow control")
Since then, additional requirements for serial core support have arisen.
Specifically,
1. Separate tx and rx flow control settings for UARTs which only support
tx flow control (ie., autoCTS).
2. Disable sw-assisted CTS flow control in autoCTS mode
3. Support for RTS flow control by serial core and userspace in autoRTS mode
Distinguish mode from capability; introduce UPSTAT_AUTORTS, UPSTAT_AUTOCTS
and UPSTAT_AUTOXOFF which, when set by the uart driver, enable serial core
support for hw-assisted rx, hw-assisted tx and hw-assisted in-band/IXOFF
rx flow control, respectively. [Note: hw-assisted in-band/IXON tx flow
control does not require serial core support/intervention and can be
enabled by the uart driver when required.]
These modes must be set/reset in the driver's set_termios() method, based
on termios settings, and thus can be safely queried in any context in which
one of the port lock, port mutex or termios rwsem are held. Set these modes
in the 2 in-tree drivers, omap-serial and 8250_omap, which currently
use UPF_HARD_FLOW/UPF_SOFT_FLOW support.
Retain UPF_HARD_FLOW and UPF_SOFT_FLOW as capabilities; re-define
UPF_HARD_FLOW as both UPF_AUTO_RTS and UPF_AUTO_CTS to allow for distinct
and separate rx and tx flow control capabilities.
Disable sw-assisted CTS flow control when UPSTAT_AUTOCTS is enabled.
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2015-01-25 19:44:51 +00:00
|
|
|
/* Port has hardware-assisted h/w flow control */
|
|
|
|
#define UPF_AUTO_CTS ((__force upf_t) (1 << 20))
|
|
|
|
#define UPF_AUTO_RTS ((__force upf_t) (1 << 21))
|
|
|
|
#define UPF_HARD_FLOW ((__force upf_t) (UPF_AUTO_CTS | UPF_AUTO_RTS))
|
2012-04-17 15:34:13 +00:00
|
|
|
/* Port has hardware-assisted s/w flow control */
|
|
|
|
#define UPF_SOFT_FLOW ((__force upf_t) (1 << 22))
|
2006-01-21 23:03:28 +00:00
|
|
|
#define UPF_CONS_FLOW ((__force upf_t) (1 << 23))
|
|
|
|
#define UPF_SHARE_IRQ ((__force upf_t) (1 << 24))
|
2011-09-02 20:55:37 +00:00
|
|
|
#define UPF_EXAR_EFR ((__force upf_t) (1 << 25))
|
2012-04-06 18:49:50 +00:00
|
|
|
#define UPF_BUG_THRE ((__force upf_t) (1 << 26))
|
2009-01-02 13:49:54 +00:00
|
|
|
/* The exact UART type is known and should not be probed. */
|
|
|
|
#define UPF_FIXED_TYPE ((__force upf_t) (1 << 27))
|
2006-01-21 23:03:28 +00:00
|
|
|
#define UPF_BOOT_AUTOCONF ((__force upf_t) (1 << 28))
|
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-06 21:48:49 +00:00
|
|
|
#define UPF_FIXED_PORT ((__force upf_t) (1 << 29))
|
2006-04-30 10:13:50 +00:00
|
|
|
#define UPF_DEAD ((__force upf_t) (1 << 30))
|
2006-01-21 23:03:28 +00:00
|
|
|
#define UPF_IOREMAP ((__force upf_t) (1 << 31))
|
|
|
|
|
2014-10-16 20:54:21 +00:00
|
|
|
#define __UPF_CHANGE_MASK 0x17fff
|
|
|
|
#define UPF_CHANGE_MASK ((__force upf_t) __UPF_CHANGE_MASK)
|
2006-01-21 23:03:28 +00:00
|
|
|
#define UPF_USR_MASK ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-10-16 20:54:21 +00:00
|
|
|
#if __UPF_CHANGE_MASK > ASYNC_FLAGS
|
|
|
|
#error Change mask not equivalent to userspace-visible bit defines
|
|
|
|
#endif
|
|
|
|
|
serial: core: Rework hw-assisted flow control support
hw-assisted flow control support was added to the serial core
in v3.8 with commits,
dba05832cbe4f ("SERIAL: core: add hardware assisted h/w flow control support")
2cbacafd7af0f ("SERIAL: core: add hardware assisted s/w flow control support")
9aba8d5b01119 ("SERIAL: core: add throttle/unthrottle callbacks for hardware
assisted flow control")
Since then, additional requirements for serial core support have arisen.
Specifically,
1. Separate tx and rx flow control settings for UARTs which only support
tx flow control (ie., autoCTS).
2. Disable sw-assisted CTS flow control in autoCTS mode
3. Support for RTS flow control by serial core and userspace in autoRTS mode
Distinguish mode from capability; introduce UPSTAT_AUTORTS, UPSTAT_AUTOCTS
and UPSTAT_AUTOXOFF which, when set by the uart driver, enable serial core
support for hw-assisted rx, hw-assisted tx and hw-assisted in-band/IXOFF
rx flow control, respectively. [Note: hw-assisted in-band/IXON tx flow
control does not require serial core support/intervention and can be
enabled by the uart driver when required.]
These modes must be set/reset in the driver's set_termios() method, based
on termios settings, and thus can be safely queried in any context in which
one of the port lock, port mutex or termios rwsem are held. Set these modes
in the 2 in-tree drivers, omap-serial and 8250_omap, which currently
use UPF_HARD_FLOW/UPF_SOFT_FLOW support.
Retain UPF_HARD_FLOW and UPF_SOFT_FLOW as capabilities; re-define
UPF_HARD_FLOW as both UPF_AUTO_RTS and UPF_AUTO_CTS to allow for distinct
and separate rx and tx flow control capabilities.
Disable sw-assisted CTS flow control when UPSTAT_AUTOCTS is enabled.
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2015-01-25 19:44:51 +00:00
|
|
|
/*
|
|
|
|
* Must hold termios_rwsem, port mutex and port lock to change;
|
|
|
|
* can hold any one lock to read.
|
|
|
|
*/
|
2014-09-10 19:06:24 +00:00
|
|
|
upstat_t status;
|
|
|
|
|
|
|
|
#define UPSTAT_CTS_ENABLE ((__force upstat_t) (1 << 0))
|
|
|
|
#define UPSTAT_DCD_ENABLE ((__force upstat_t) (1 << 1))
|
serial: core: Rework hw-assisted flow control support
hw-assisted flow control support was added to the serial core
in v3.8 with commits,
dba05832cbe4f ("SERIAL: core: add hardware assisted h/w flow control support")
2cbacafd7af0f ("SERIAL: core: add hardware assisted s/w flow control support")
9aba8d5b01119 ("SERIAL: core: add throttle/unthrottle callbacks for hardware
assisted flow control")
Since then, additional requirements for serial core support have arisen.
Specifically,
1. Separate tx and rx flow control settings for UARTs which only support
tx flow control (ie., autoCTS).
2. Disable sw-assisted CTS flow control in autoCTS mode
3. Support for RTS flow control by serial core and userspace in autoRTS mode
Distinguish mode from capability; introduce UPSTAT_AUTORTS, UPSTAT_AUTOCTS
and UPSTAT_AUTOXOFF which, when set by the uart driver, enable serial core
support for hw-assisted rx, hw-assisted tx and hw-assisted in-band/IXOFF
rx flow control, respectively. [Note: hw-assisted in-band/IXON tx flow
control does not require serial core support/intervention and can be
enabled by the uart driver when required.]
These modes must be set/reset in the driver's set_termios() method, based
on termios settings, and thus can be safely queried in any context in which
one of the port lock, port mutex or termios rwsem are held. Set these modes
in the 2 in-tree drivers, omap-serial and 8250_omap, which currently
use UPF_HARD_FLOW/UPF_SOFT_FLOW support.
Retain UPF_HARD_FLOW and UPF_SOFT_FLOW as capabilities; re-define
UPF_HARD_FLOW as both UPF_AUTO_RTS and UPF_AUTO_CTS to allow for distinct
and separate rx and tx flow control capabilities.
Disable sw-assisted CTS flow control when UPSTAT_AUTOCTS is enabled.
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2015-01-25 19:44:51 +00:00
|
|
|
#define UPSTAT_AUTORTS ((__force upstat_t) (1 << 2))
|
|
|
|
#define UPSTAT_AUTOCTS ((__force upstat_t) (1 << 3))
|
|
|
|
#define UPSTAT_AUTOXOFF ((__force upstat_t) (1 << 4))
|
2018-03-27 03:48:24 +00:00
|
|
|
#define UPSTAT_SYNC_FIFO ((__force upstat_t) (1 << 5))
|
2014-09-10 19:06:24 +00:00
|
|
|
|
2014-09-10 19:06:26 +00:00
|
|
|
int hw_stopped; /* sw-assisted CTS flow state */
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int mctrl; /* current modem ctrl settings */
|
|
|
|
unsigned int timeout; /* character-based timeout */
|
|
|
|
unsigned int type; /* port type */
|
2006-01-21 22:45:50 +00:00
|
|
|
const struct uart_ops *ops;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int custom_divisor;
|
|
|
|
unsigned int line; /* port index */
|
2015-02-24 19:25:00 +00:00
|
|
|
unsigned int minor;
|
2007-07-24 01:43:44 +00:00
|
|
|
resource_size_t mapbase; /* for ioremap */
|
2015-03-08 14:30:04 +00:00
|
|
|
resource_size_t mapsize;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct device *dev; /* parent device */
|
|
|
|
unsigned char hub6; /* this should be in the 8250 driver */
|
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 08:24:02 +00:00
|
|
|
unsigned char suspended;
|
2018-10-04 16:57:23 +00:00
|
|
|
unsigned char unused[2];
|
2017-03-31 18:35:17 +00:00
|
|
|
const char *name; /* port name */
|
2014-07-16 01:19:34 +00:00
|
|
|
struct attribute_group *attr_group; /* port specific attributes */
|
|
|
|
const struct attribute_group **tty_groups; /* all attributes (serial core use only) */
|
2014-11-06 21:46:13 +00:00
|
|
|
struct serial_rs485 rs485;
|
2018-09-26 12:58:47 +00:00
|
|
|
struct serial_iso7816 iso7816;
|
2007-05-06 21:48:45 +00:00
|
|
|
void *private_data; /* generic platform data pointer */
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2012-03-09 00:12:12 +00:00
|
|
|
static inline int serial_port_in(struct uart_port *up, int offset)
|
|
|
|
{
|
|
|
|
return up->serial_in(up, offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void serial_port_out(struct uart_port *up, int offset, int value)
|
|
|
|
{
|
|
|
|
up->serial_out(up, offset, value);
|
|
|
|
}
|
|
|
|
|
2012-12-07 10:36:08 +00:00
|
|
|
/**
|
|
|
|
* enum uart_pm_state - power states for UARTs
|
|
|
|
* @UART_PM_STATE_ON: UART is powered, up and operational
|
|
|
|
* @UART_PM_STATE_OFF: UART is powered off
|
|
|
|
* @UART_PM_STATE_UNDEFINED: sentinel
|
|
|
|
*/
|
|
|
|
enum uart_pm_state {
|
|
|
|
UART_PM_STATE_ON = 0,
|
|
|
|
UART_PM_STATE_OFF = 3, /* number taken from ACPI */
|
|
|
|
UART_PM_STATE_UNDEFINED,
|
|
|
|
};
|
|
|
|
|
2009-09-19 20:13:28 +00:00
|
|
|
/*
|
|
|
|
* This is the state information which is persistent across opens.
|
|
|
|
*/
|
|
|
|
struct uart_state {
|
2008-07-16 20:53:50 +00:00
|
|
|
struct tty_port port;
|
2009-09-19 20:13:28 +00:00
|
|
|
|
2012-12-07 10:36:08 +00:00
|
|
|
enum uart_pm_state pm_state;
|
2005-04-16 22:20:36 +00:00
|
|
|
struct circ_buf xmit;
|
|
|
|
|
serial: core: Prevent unsafe uart port access, part 2
For serial core operations not already excluded by holding port->mutex,
use reference counting to protect deferencing the state->uart_port.
Introduce helper functions, uart_port_ref() and uart_port_deref(), to
wrap uart_port access, and helper macros, uart_port_lock() and
uart_port_unlock(), to wrap combination uart_port access with uart
port lock sections.
Port removal in uart_remove_one_port() waits for reference count to
drop to zero before detaching the uart port from struct uart_state.
For functions only reading the tx circular buffer indexes (where the
uart port lock is claimed to prevent concurrent users), a NULL uart
port is simply ignored and the operation completes normally.
For functions change the tx circular buffer indexes (where the uart
port lock is claimed to prevent concurrent users), the operation is
aborted if the uart port is NULL (ie., has been detached).
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2016-04-10 01:56:34 +00:00
|
|
|
atomic_t refcount;
|
|
|
|
wait_queue_head_t remove_wait;
|
2009-09-19 20:13:28 +00:00
|
|
|
struct uart_port *uart_port;
|
2009-01-02 13:49:21 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
#define UART_XMIT_SIZE PAGE_SIZE
|
|
|
|
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* number of characters left in xmit buffer before we ask for more */
|
|
|
|
#define WAKEUP_CHARS 256
|
|
|
|
|
|
|
|
struct module;
|
|
|
|
struct tty_driver;
|
|
|
|
|
|
|
|
struct uart_driver {
|
|
|
|
struct module *owner;
|
|
|
|
const char *driver_name;
|
|
|
|
const char *dev_name;
|
|
|
|
int major;
|
|
|
|
int minor;
|
|
|
|
int nr;
|
|
|
|
struct console *cons;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* these are private; the low level driver should not
|
|
|
|
* touch these; they should be initialised to NULL
|
|
|
|
*/
|
|
|
|
struct uart_state *state;
|
|
|
|
struct tty_driver *tty_driver;
|
|
|
|
};
|
|
|
|
|
|
|
|
void uart_write_wakeup(struct uart_port *port);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Baud rate helpers.
|
|
|
|
*/
|
|
|
|
void uart_update_timeout(struct uart_port *port, unsigned int cflag,
|
|
|
|
unsigned int baud);
|
2006-12-08 10:38:45 +00:00
|
|
|
unsigned int uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
|
|
|
|
struct ktermios *old, unsigned int min,
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned int max);
|
|
|
|
unsigned int uart_get_divisor(struct uart_port *port, unsigned int baud);
|
|
|
|
|
2010-10-01 13:21:25 +00:00
|
|
|
/* Base timer interval for polling */
|
|
|
|
static inline int uart_poll_timeout(struct uart_port *port)
|
|
|
|
{
|
|
|
|
int timeout = port->timeout;
|
|
|
|
|
|
|
|
return timeout > 6 ? (timeout / 2 - 2) : 1;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Console helpers.
|
|
|
|
*/
|
2014-04-18 22:19:55 +00:00
|
|
|
struct earlycon_device {
|
|
|
|
struct console *con;
|
|
|
|
struct uart_port port;
|
|
|
|
char options[16]; /* e.g., 115200n8 */
|
|
|
|
unsigned int baud;
|
|
|
|
};
|
|
|
|
|
2015-03-09 20:27:21 +00:00
|
|
|
struct earlycon_id {
|
2018-03-23 17:58:31 +00:00
|
|
|
char name[15];
|
|
|
|
char name_term; /* In case compiler didn't '\0' term name */
|
2016-01-16 23:23:39 +00:00
|
|
|
char compatible[128];
|
2015-03-09 20:27:21 +00:00
|
|
|
int (*setup)(struct earlycon_device *, const char *options);
|
2018-04-06 23:21:53 +00:00
|
|
|
};
|
2015-03-09 20:27:21 +00:00
|
|
|
|
2018-04-06 23:21:53 +00:00
|
|
|
extern const struct earlycon_id *__earlycon_table[];
|
|
|
|
extern const struct earlycon_id *__earlycon_table_end[];
|
2016-01-16 23:23:39 +00:00
|
|
|
|
2016-06-06 09:41:00 +00:00
|
|
|
#if defined(CONFIG_SERIAL_EARLYCON) && !defined(MODULE)
|
|
|
|
#define EARLYCON_USED_OR_UNUSED __used
|
|
|
|
#else
|
|
|
|
#define EARLYCON_USED_OR_UNUSED __maybe_unused
|
|
|
|
#endif
|
|
|
|
|
2018-04-06 23:21:53 +00:00
|
|
|
#define _OF_EARLYCON_DECLARE(_name, compat, fn, unique_id) \
|
|
|
|
static const struct earlycon_id unique_id \
|
|
|
|
EARLYCON_USED_OR_UNUSED __initconst \
|
2016-01-16 23:23:39 +00:00
|
|
|
= { .name = __stringify(_name), \
|
|
|
|
.compatible = compat, \
|
2018-04-06 23:21:53 +00:00
|
|
|
.setup = fn }; \
|
|
|
|
static const struct earlycon_id EARLYCON_USED_OR_UNUSED \
|
|
|
|
__section(__earlycon_table) \
|
|
|
|
* const __PASTE(__p, unique_id) = &unique_id
|
|
|
|
|
|
|
|
#define OF_EARLYCON_DECLARE(_name, compat, fn) \
|
|
|
|
_OF_EARLYCON_DECLARE(_name, compat, fn, \
|
|
|
|
__UNIQUE_ID(__earlycon_##_name))
|
2016-01-16 23:23:39 +00:00
|
|
|
|
|
|
|
#define EARLYCON_DECLARE(_name, fn) OF_EARLYCON_DECLARE(_name, "", fn)
|
|
|
|
|
2016-01-16 23:23:44 +00:00
|
|
|
extern int of_setup_earlycon(const struct earlycon_id *match,
|
2016-01-16 23:23:43 +00:00
|
|
|
unsigned long node,
|
2016-01-16 23:23:42 +00:00
|
|
|
const char *options);
|
2014-03-27 13:06:16 +00:00
|
|
|
|
2016-09-27 20:54:13 +00:00
|
|
|
#ifdef CONFIG_SERIAL_EARLYCON
|
2018-01-18 15:09:51 +00:00
|
|
|
extern bool earlycon_acpi_spcr_enable __initdata;
|
2016-09-27 20:54:13 +00:00
|
|
|
int setup_earlycon(char *buf);
|
|
|
|
#else
|
2018-03-10 18:06:45 +00:00
|
|
|
static const bool earlycon_acpi_spcr_enable EARLYCON_USED_OR_UNUSED;
|
2016-09-27 20:54:13 +00:00
|
|
|
static inline int setup_earlycon(char *buf) { return 0; }
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct uart_port *uart_get_console(struct uart_port *ports, int nr,
|
|
|
|
struct console *c);
|
2016-09-02 11:20:21 +00:00
|
|
|
int uart_parse_earlycon(char *p, unsigned char *iotype, resource_size_t *addr,
|
serial: earlycon: Refactor parse_options into serial core
Prepare to support console-defined matching; refactor the command
line parameter string processing from parse_options() into a
new core function, uart_parse_earlycon(), which decodes command line
parameters of the form:
earlycon=<name>,io|mmio|mmio32,<addr>,<options>
console=<name>,io|mmio|mmio32,<addr>,<options>
earlycon=<name>,0x<addr>,<options>
console=<name>,0x<addr>,<options>
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2015-03-01 16:05:46 +00:00
|
|
|
char **options);
|
2017-12-28 13:07:07 +00:00
|
|
|
void uart_parse_options(const char *options, int *baud, int *parity, int *bits,
|
2005-04-16 22:20:36 +00:00
|
|
|
int *flow);
|
|
|
|
int uart_set_options(struct uart_port *port, struct console *co, int baud,
|
|
|
|
int parity, int bits, int flow);
|
|
|
|
struct tty_driver *uart_console_device(struct console *co, int *index);
|
2006-03-20 20:00:09 +00:00
|
|
|
void uart_console_write(struct uart_port *port, const char *s,
|
|
|
|
unsigned int count,
|
|
|
|
void (*putchar)(struct uart_port *, int));
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Port/driver registration/removal
|
|
|
|
*/
|
|
|
|
int uart_register_driver(struct uart_driver *uart);
|
|
|
|
void uart_unregister_driver(struct uart_driver *uart);
|
|
|
|
int uart_add_one_port(struct uart_driver *reg, struct uart_port *port);
|
|
|
|
int uart_remove_one_port(struct uart_driver *reg, struct uart_port *port);
|
|
|
|
int uart_match_port(struct uart_port *port1, struct uart_port *port2);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Power Management
|
|
|
|
*/
|
|
|
|
int uart_suspend_port(struct uart_driver *reg, struct uart_port *port);
|
|
|
|
int uart_resume_port(struct uart_driver *reg, struct uart_port *port);
|
|
|
|
|
|
|
|
#define uart_circ_empty(circ) ((circ)->head == (circ)->tail)
|
|
|
|
#define uart_circ_clear(circ) ((circ)->head = (circ)->tail = 0)
|
|
|
|
|
|
|
|
#define uart_circ_chars_pending(circ) \
|
|
|
|
(CIRC_CNT((circ)->head, (circ)->tail, UART_XMIT_SIZE))
|
|
|
|
|
|
|
|
#define uart_circ_chars_free(circ) \
|
|
|
|
(CIRC_SPACE((circ)->head, (circ)->tail, UART_XMIT_SIZE))
|
|
|
|
|
2009-01-02 13:49:21 +00:00
|
|
|
static inline int uart_tx_stopped(struct uart_port *port)
|
|
|
|
{
|
2009-09-19 20:13:28 +00:00
|
|
|
struct tty_struct *tty = port->state->port.tty;
|
2016-09-09 22:37:02 +00:00
|
|
|
if ((tty && tty->stopped) || port->hw_stopped)
|
2009-01-02 13:49:21 +00:00
|
|
|
return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-09-10 19:06:24 +00:00
|
|
|
static inline bool uart_cts_enabled(struct uart_port *uport)
|
|
|
|
{
|
2014-10-16 18:19:47 +00:00
|
|
|
return !!(uport->status & UPSTAT_CTS_ENABLE);
|
2014-09-10 19:06:24 +00:00
|
|
|
}
|
|
|
|
|
serial: core: Rework hw-assisted flow control support
hw-assisted flow control support was added to the serial core
in v3.8 with commits,
dba05832cbe4f ("SERIAL: core: add hardware assisted h/w flow control support")
2cbacafd7af0f ("SERIAL: core: add hardware assisted s/w flow control support")
9aba8d5b01119 ("SERIAL: core: add throttle/unthrottle callbacks for hardware
assisted flow control")
Since then, additional requirements for serial core support have arisen.
Specifically,
1. Separate tx and rx flow control settings for UARTs which only support
tx flow control (ie., autoCTS).
2. Disable sw-assisted CTS flow control in autoCTS mode
3. Support for RTS flow control by serial core and userspace in autoRTS mode
Distinguish mode from capability; introduce UPSTAT_AUTORTS, UPSTAT_AUTOCTS
and UPSTAT_AUTOXOFF which, when set by the uart driver, enable serial core
support for hw-assisted rx, hw-assisted tx and hw-assisted in-band/IXOFF
rx flow control, respectively. [Note: hw-assisted in-band/IXON tx flow
control does not require serial core support/intervention and can be
enabled by the uart driver when required.]
These modes must be set/reset in the driver's set_termios() method, based
on termios settings, and thus can be safely queried in any context in which
one of the port lock, port mutex or termios rwsem are held. Set these modes
in the 2 in-tree drivers, omap-serial and 8250_omap, which currently
use UPF_HARD_FLOW/UPF_SOFT_FLOW support.
Retain UPF_HARD_FLOW and UPF_SOFT_FLOW as capabilities; re-define
UPF_HARD_FLOW as both UPF_AUTO_RTS and UPF_AUTO_CTS to allow for distinct
and separate rx and tx flow control capabilities.
Disable sw-assisted CTS flow control when UPSTAT_AUTOCTS is enabled.
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
2015-01-25 19:44:51 +00:00
|
|
|
static inline bool uart_softcts_mode(struct uart_port *uport)
|
|
|
|
{
|
|
|
|
upstat_t mask = UPSTAT_CTS_ENABLE | UPSTAT_AUTOCTS;
|
|
|
|
|
|
|
|
return ((uport->status & mask) == UPSTAT_CTS_ENABLE);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* The following are helper functions for the low level drivers.
|
|
|
|
*/
|
2011-11-09 20:33:43 +00:00
|
|
|
|
|
|
|
extern void uart_handle_dcd_change(struct uart_port *uport,
|
|
|
|
unsigned int status);
|
|
|
|
extern void uart_handle_cts_change(struct uart_port *uport,
|
|
|
|
unsigned int status);
|
|
|
|
|
|
|
|
extern void uart_insert_char(struct uart_port *port, unsigned int status,
|
|
|
|
unsigned int overrun, unsigned int ch, unsigned int flag);
|
|
|
|
|
2016-12-22 07:31:34 +00:00
|
|
|
#if defined(SUPPORT_SYSRQ) && defined(CONFIG_MAGIC_SYSRQ_SERIAL)
|
2005-04-16 22:20:36 +00:00
|
|
|
static inline int
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 13:55:46 +00:00
|
|
|
uart_handle_sysrq_char(struct uart_port *port, unsigned int ch)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
if (port->sysrq) {
|
|
|
|
if (ch && time_before(jiffies, port->sysrq)) {
|
2010-08-18 04:15:47 +00:00
|
|
|
handle_sysrq(ch);
|
2005-04-16 22:20:36 +00:00
|
|
|
port->sysrq = 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
port->sysrq = 0;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
2018-10-30 22:11:04 +00:00
|
|
|
static inline int
|
|
|
|
uart_prepare_sysrq_char(struct uart_port *port, unsigned int ch)
|
|
|
|
{
|
|
|
|
if (port->sysrq) {
|
|
|
|
if (ch && time_before(jiffies, port->sysrq)) {
|
|
|
|
port->sysrq_ch = ch;
|
|
|
|
port->sysrq = 0;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
port->sysrq = 0;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
static inline void
|
|
|
|
uart_unlock_and_check_sysrq(struct uart_port *port, unsigned long irqflags)
|
|
|
|
{
|
|
|
|
int sysrq_ch;
|
|
|
|
|
|
|
|
sysrq_ch = port->sysrq_ch;
|
|
|
|
port->sysrq_ch = 0;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&port->lock, irqflags);
|
|
|
|
|
|
|
|
if (sysrq_ch)
|
|
|
|
handle_sysrq(sysrq_ch);
|
|
|
|
}
|
2011-11-09 20:33:43 +00:00
|
|
|
#else
|
2018-10-30 22:11:04 +00:00
|
|
|
static inline int
|
|
|
|
uart_handle_sysrq_char(struct uart_port *port, unsigned int ch) { return 0; }
|
|
|
|
static inline int
|
|
|
|
uart_prepare_sysrq_char(struct uart_port *port, unsigned int ch) { return 0; }
|
|
|
|
static inline void
|
|
|
|
uart_unlock_and_check_sysrq(struct uart_port *port, unsigned long irqflags)
|
|
|
|
{
|
|
|
|
spin_unlock_irqrestore(&port->lock, irqflags);
|
|
|
|
}
|
2005-09-08 21:47:12 +00:00
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* We do the SysRQ and SAK checking like this...
|
|
|
|
*/
|
|
|
|
static inline int uart_handle_break(struct uart_port *port)
|
|
|
|
{
|
2009-09-19 20:13:28 +00:00
|
|
|
struct uart_state *state = port->state;
|
2012-04-10 21:10:53 +00:00
|
|
|
|
|
|
|
if (port->handle_break)
|
|
|
|
port->handle_break(port);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef SUPPORT_SYSRQ
|
|
|
|
if (port->cons && port->cons->index == port->line) {
|
|
|
|
if (!port->sysrq) {
|
|
|
|
port->sysrq = jiffies + HZ*5;
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
port->sysrq = 0;
|
|
|
|
}
|
|
|
|
#endif
|
2006-01-21 22:54:06 +00:00
|
|
|
if (port->flags & UPF_SAK)
|
2009-09-19 20:13:28 +00:00
|
|
|
do_SAK(state->port.tty);
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* UART_ENABLE_MS - determine if port should enable modem status irqs
|
|
|
|
*/
|
|
|
|
#define UART_ENABLE_MS(port,cflag) ((port)->flags & UPF_HARDPPS_CD || \
|
|
|
|
(cflag) & CRTSCTS || \
|
|
|
|
!((cflag) & CLOCAL))
|
|
|
|
|
2017-11-24 22:26:40 +00:00
|
|
|
void uart_get_rs485_mode(struct device *dev, struct serial_rs485 *rs485conf);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* LINUX_SERIAL_CORE_H */
|