Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0-or-later */
       2                 :            : /*
       3                 :            :  *  linux/drivers/char/serial_core.h
       4                 :            :  *
       5                 :            :  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
       6                 :            :  */
       7                 :            : #ifndef LINUX_SERIAL_CORE_H
       8                 :            : #define LINUX_SERIAL_CORE_H
       9                 :            : 
      10                 :            : #include <linux/bitops.h>
      11                 :            : #include <linux/compiler.h>
      12                 :            : #include <linux/console.h>
      13                 :            : #include <linux/interrupt.h>
      14                 :            : #include <linux/circ_buf.h>
      15                 :            : #include <linux/spinlock.h>
      16                 :            : #include <linux/sched.h>
      17                 :            : #include <linux/tty.h>
      18                 :            : #include <linux/mutex.h>
      19                 :            : #include <linux/sysrq.h>
      20                 :            : #include <uapi/linux/serial_core.h>
      21                 :            : 
      22                 :            : #ifdef CONFIG_SERIAL_CORE_CONSOLE
      23                 :            : #define uart_console(port) \
      24                 :            :         ((port)->cons && (port)->cons->index == (port)->line)
      25                 :            : #else
      26                 :            : #define uart_console(port)      ({ (void)port; 0; })
      27                 :            : #endif
      28                 :            : 
      29                 :            : struct uart_port;
      30                 :            : struct serial_struct;
      31                 :            : struct device;
      32                 :            : 
      33                 :            : /*
      34                 :            :  * This structure describes all the operations that can be done on the
      35                 :            :  * physical hardware.  See Documentation/driver-api/serial/driver.rst for details.
      36                 :            :  */
      37                 :            : struct uart_ops {
      38                 :            :         unsigned int    (*tx_empty)(struct uart_port *);
      39                 :            :         void            (*set_mctrl)(struct uart_port *, unsigned int mctrl);
      40                 :            :         unsigned int    (*get_mctrl)(struct uart_port *);
      41                 :            :         void            (*stop_tx)(struct uart_port *);
      42                 :            :         void            (*start_tx)(struct uart_port *);
      43                 :            :         void            (*throttle)(struct uart_port *);
      44                 :            :         void            (*unthrottle)(struct uart_port *);
      45                 :            :         void            (*send_xchar)(struct uart_port *, char ch);
      46                 :            :         void            (*stop_rx)(struct uart_port *);
      47                 :            :         void            (*enable_ms)(struct uart_port *);
      48                 :            :         void            (*break_ctl)(struct uart_port *, int ctl);
      49                 :            :         int             (*startup)(struct uart_port *);
      50                 :            :         void            (*shutdown)(struct uart_port *);
      51                 :            :         void            (*flush_buffer)(struct uart_port *);
      52                 :            :         void            (*set_termios)(struct uart_port *, struct ktermios *new,
      53                 :            :                                        struct ktermios *old);
      54                 :            :         void            (*set_ldisc)(struct uart_port *, struct ktermios *);
      55                 :            :         void            (*pm)(struct uart_port *, unsigned int state,
      56                 :            :                               unsigned int oldstate);
      57                 :            : 
      58                 :            :         /*
      59                 :            :          * Return a string describing the type of the port
      60                 :            :          */
      61                 :            :         const char      *(*type)(struct uart_port *);
      62                 :            : 
      63                 :            :         /*
      64                 :            :          * Release IO and memory resources used by the port.
      65                 :            :          * This includes iounmap if necessary.
      66                 :            :          */
      67                 :            :         void            (*release_port)(struct uart_port *);
      68                 :            : 
      69                 :            :         /*
      70                 :            :          * Request IO and memory resources used by the port.
      71                 :            :          * This includes iomapping the port if necessary.
      72                 :            :          */
      73                 :            :         int             (*request_port)(struct uart_port *);
      74                 :            :         void            (*config_port)(struct uart_port *, int);
      75                 :            :         int             (*verify_port)(struct uart_port *, struct serial_struct *);
      76                 :            :         int             (*ioctl)(struct uart_port *, unsigned int, unsigned long);
      77                 :            : #ifdef CONFIG_CONSOLE_POLL
      78                 :            :         int             (*poll_init)(struct uart_port *);
      79                 :            :         void            (*poll_put_char)(struct uart_port *, unsigned char);
      80                 :            :         int             (*poll_get_char)(struct uart_port *);
      81                 :            : #endif
      82                 :            : };
      83                 :            : 
      84                 :            : #define NO_POLL_CHAR            0x00ff0000
      85                 :            : #define UART_CONFIG_TYPE        (1 << 0)
      86                 :            : #define UART_CONFIG_IRQ         (1 << 1)
      87                 :            : 
      88                 :            : struct uart_icount {
      89                 :            :         __u32   cts;
      90                 :            :         __u32   dsr;
      91                 :            :         __u32   rng;
      92                 :            :         __u32   dcd;
      93                 :            :         __u32   rx;
      94                 :            :         __u32   tx;
      95                 :            :         __u32   frame;
      96                 :            :         __u32   overrun;
      97                 :            :         __u32   parity;
      98                 :            :         __u32   brk;
      99                 :            :         __u32   buf_overrun;
     100                 :            : };
     101                 :            : 
     102                 :            : typedef unsigned int __bitwise upf_t;
     103                 :            : typedef unsigned int __bitwise upstat_t;
     104                 :            : 
     105                 :            : struct uart_port {
     106                 :            :         spinlock_t              lock;                   /* port lock */
     107                 :            :         unsigned long           iobase;                 /* in/out[bwl] */
     108                 :            :         unsigned char __iomem   *membase;               /* read/write[bwl] */
     109                 :            :         unsigned int            (*serial_in)(struct uart_port *, int);
     110                 :            :         void                    (*serial_out)(struct uart_port *, int, int);
     111                 :            :         void                    (*set_termios)(struct uart_port *,
     112                 :            :                                                struct ktermios *new,
     113                 :            :                                                struct ktermios *old);
     114                 :            :         void                    (*set_ldisc)(struct uart_port *,
     115                 :            :                                              struct ktermios *);
     116                 :            :         unsigned int            (*get_mctrl)(struct uart_port *);
     117                 :            :         void                    (*set_mctrl)(struct uart_port *, unsigned int);
     118                 :            :         unsigned int            (*get_divisor)(struct uart_port *,
     119                 :            :                                                unsigned int baud,
     120                 :            :                                                unsigned int *frac);
     121                 :            :         void                    (*set_divisor)(struct uart_port *,
     122                 :            :                                                unsigned int baud,
     123                 :            :                                                unsigned int quot,
     124                 :            :                                                unsigned int quot_frac);
     125                 :            :         int                     (*startup)(struct uart_port *port);
     126                 :            :         void                    (*shutdown)(struct uart_port *port);
     127                 :            :         void                    (*throttle)(struct uart_port *port);
     128                 :            :         void                    (*unthrottle)(struct uart_port *port);
     129                 :            :         int                     (*handle_irq)(struct uart_port *);
     130                 :            :         void                    (*pm)(struct uart_port *, unsigned int state,
     131                 :            :                                       unsigned int old);
     132                 :            :         void                    (*handle_break)(struct uart_port *);
     133                 :            :         int                     (*rs485_config)(struct uart_port *,
     134                 :            :                                                 struct serial_rs485 *rs485);
     135                 :            :         int                     (*iso7816_config)(struct uart_port *,
     136                 :            :                                                   struct serial_iso7816 *iso7816);
     137                 :            :         unsigned int            irq;                    /* irq number */
     138                 :            :         unsigned long           irqflags;               /* irq flags  */
     139                 :            :         unsigned int            uartclk;                /* base uart clock */
     140                 :            :         unsigned int            fifosize;               /* tx fifo size */
     141                 :            :         unsigned char           x_char;                 /* xon/xoff char */
     142                 :            :         unsigned char           regshift;               /* reg offset shift */
     143                 :            :         unsigned char           iotype;                 /* io access style */
     144                 :            :         unsigned char           quirks;                 /* internal quirks */
     145                 :            : 
     146                 :            : #define UPIO_PORT               (SERIAL_IO_PORT)        /* 8b I/O port access */
     147                 :            : #define UPIO_HUB6               (SERIAL_IO_HUB6)        /* Hub6 ISA card */
     148                 :            : #define UPIO_MEM                (SERIAL_IO_MEM)         /* driver-specific */
     149                 :            : #define UPIO_MEM32              (SERIAL_IO_MEM32)       /* 32b little endian */
     150                 :            : #define UPIO_AU                 (SERIAL_IO_AU)          /* Au1x00 and RT288x type IO */
     151                 :            : #define UPIO_TSI                (SERIAL_IO_TSI)         /* Tsi108/109 type IO */
     152                 :            : #define UPIO_MEM32BE            (SERIAL_IO_MEM32BE)     /* 32b big endian */
     153                 :            : #define UPIO_MEM16              (SERIAL_IO_MEM16)       /* 16b little endian */
     154                 :            : 
     155                 :            :         /* quirks must be updated while holding port mutex */
     156                 :            : #define UPQ_NO_TXEN_TEST        BIT(0)
     157                 :            : 
     158                 :            :         unsigned int            read_status_mask;       /* driver specific */
     159                 :            :         unsigned int            ignore_status_mask;     /* driver specific */
     160                 :            :         struct uart_state       *state;                 /* pointer to parent state */
     161                 :            :         struct uart_icount      icount;                 /* statistics */
     162                 :            : 
     163                 :            :         struct console          *cons;                  /* struct console, if any */
     164                 :            : #if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(SUPPORT_SYSRQ)
     165                 :            :         unsigned long           sysrq;                  /* sysrq timeout */
     166                 :            :         unsigned int            sysrq_ch;               /* char for sysrq */
     167                 :            : #endif
     168                 :            : 
     169                 :            :         /* flags must be updated while holding port mutex */
     170                 :            :         upf_t                   flags;
     171                 :            : 
     172                 :            :         /*
     173                 :            :          * These flags must be equivalent to the flags defined in
     174                 :            :          * include/uapi/linux/tty_flags.h which are the userspace definitions
     175                 :            :          * assigned from the serial_struct flags in uart_set_info()
     176                 :            :          * [for bit definitions in the UPF_CHANGE_MASK]
     177                 :            :          *
     178                 :            :          * Bits [0..UPF_LAST_USER] are userspace defined/visible/changeable
     179                 :            :          * The remaining bits are serial-core specific and not modifiable by
     180                 :            :          * userspace.
     181                 :            :          */
     182                 :            : #define UPF_FOURPORT            ((__force upf_t) ASYNC_FOURPORT       /* 1  */ )
     183                 :            : #define UPF_SAK                 ((__force upf_t) ASYNC_SAK            /* 2  */ )
     184                 :            : #define UPF_SPD_HI              ((__force upf_t) ASYNC_SPD_HI         /* 4  */ )
     185                 :            : #define UPF_SPD_VHI             ((__force upf_t) ASYNC_SPD_VHI        /* 5  */ )
     186                 :            : #define UPF_SPD_CUST            ((__force upf_t) ASYNC_SPD_CUST   /* 0x0030 */ )
     187                 :            : #define UPF_SPD_WARP            ((__force upf_t) ASYNC_SPD_WARP   /* 0x1010 */ )
     188                 :            : #define UPF_SPD_MASK            ((__force upf_t) ASYNC_SPD_MASK   /* 0x1030 */ )
     189                 :            : #define UPF_SKIP_TEST           ((__force upf_t) ASYNC_SKIP_TEST      /* 6  */ )
     190                 :            : #define UPF_AUTO_IRQ            ((__force upf_t) ASYNC_AUTO_IRQ       /* 7  */ )
     191                 :            : #define UPF_HARDPPS_CD          ((__force upf_t) ASYNC_HARDPPS_CD     /* 11 */ )
     192                 :            : #define UPF_SPD_SHI             ((__force upf_t) ASYNC_SPD_SHI        /* 12 */ )
     193                 :            : #define UPF_LOW_LATENCY         ((__force upf_t) ASYNC_LOW_LATENCY    /* 13 */ )
     194                 :            : #define UPF_BUGGY_UART          ((__force upf_t) ASYNC_BUGGY_UART     /* 14 */ )
     195                 :            : #define UPF_MAGIC_MULTIPLIER    ((__force upf_t) ASYNC_MAGIC_MULTIPLIER /* 16 */ )
     196                 :            : 
     197                 :            : #define UPF_NO_THRE_TEST        ((__force upf_t) (1 << 19))
     198                 :            : /* Port has hardware-assisted h/w flow control */
     199                 :            : #define UPF_AUTO_CTS            ((__force upf_t) (1 << 20))
     200                 :            : #define UPF_AUTO_RTS            ((__force upf_t) (1 << 21))
     201                 :            : #define UPF_HARD_FLOW           ((__force upf_t) (UPF_AUTO_CTS | UPF_AUTO_RTS))
     202                 :            : /* Port has hardware-assisted s/w flow control */
     203                 :            : #define UPF_SOFT_FLOW           ((__force upf_t) (1 << 22))
     204                 :            : #define UPF_CONS_FLOW           ((__force upf_t) (1 << 23))
     205                 :            : #define UPF_SHARE_IRQ           ((__force upf_t) (1 << 24))
     206                 :            : #define UPF_EXAR_EFR            ((__force upf_t) (1 << 25))
     207                 :            : #define UPF_BUG_THRE            ((__force upf_t) (1 << 26))
     208                 :            : /* The exact UART type is known and should not be probed.  */
     209                 :            : #define UPF_FIXED_TYPE          ((__force upf_t) (1 << 27))
     210                 :            : #define UPF_BOOT_AUTOCONF       ((__force upf_t) (1 << 28))
     211                 :            : #define UPF_FIXED_PORT          ((__force upf_t) (1 << 29))
     212                 :            : #define UPF_DEAD                ((__force upf_t) (1 << 30))
     213                 :            : #define UPF_IOREMAP             ((__force upf_t) (1 << 31))
     214                 :            : 
     215                 :            : #define __UPF_CHANGE_MASK       0x17fff
     216                 :            : #define UPF_CHANGE_MASK         ((__force upf_t) __UPF_CHANGE_MASK)
     217                 :            : #define UPF_USR_MASK            ((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))
     218                 :            : 
     219                 :            : #if __UPF_CHANGE_MASK > ASYNC_FLAGS
     220                 :            : #error Change mask not equivalent to userspace-visible bit defines
     221                 :            : #endif
     222                 :            : 
     223                 :            :         /*
     224                 :            :          * Must hold termios_rwsem, port mutex and port lock to change;
     225                 :            :          * can hold any one lock to read.
     226                 :            :          */
     227                 :            :         upstat_t                status;
     228                 :            : 
     229                 :            : #define UPSTAT_CTS_ENABLE       ((__force upstat_t) (1 << 0))
     230                 :            : #define UPSTAT_DCD_ENABLE       ((__force upstat_t) (1 << 1))
     231                 :            : #define UPSTAT_AUTORTS          ((__force upstat_t) (1 << 2))
     232                 :            : #define UPSTAT_AUTOCTS          ((__force upstat_t) (1 << 3))
     233                 :            : #define UPSTAT_AUTOXOFF         ((__force upstat_t) (1 << 4))
     234                 :            : #define UPSTAT_SYNC_FIFO        ((__force upstat_t) (1 << 5))
     235                 :            : 
     236                 :            :         int                     hw_stopped;             /* sw-assisted CTS flow state */
     237                 :            :         unsigned int            mctrl;                  /* current modem ctrl settings */
     238                 :            :         unsigned int            timeout;                /* character-based timeout */
     239                 :            :         unsigned int            type;                   /* port type */
     240                 :            :         const struct uart_ops   *ops;
     241                 :            :         unsigned int            custom_divisor;
     242                 :            :         unsigned int            line;                   /* port index */
     243                 :            :         unsigned int            minor;
     244                 :            :         resource_size_t         mapbase;                /* for ioremap */
     245                 :            :         resource_size_t         mapsize;
     246                 :            :         struct device           *dev;                   /* parent device */
     247                 :            :         unsigned char           hub6;                   /* this should be in the 8250 driver */
     248                 :            :         unsigned char           suspended;
     249                 :            :         unsigned char           unused[2];
     250                 :            :         const char              *name;                  /* port name */
     251                 :            :         struct attribute_group  *attr_group;            /* port specific attributes */
     252                 :            :         const struct attribute_group **tty_groups;      /* all attributes (serial core use only) */
     253                 :            :         struct serial_rs485     rs485;
     254                 :            :         struct serial_iso7816   iso7816;
     255                 :            :         void                    *private_data;          /* generic platform data pointer */
     256                 :            : };
     257                 :            : 
     258                 :            : static inline int serial_port_in(struct uart_port *up, int offset)
     259                 :            : {
     260                 :          0 :         return up->serial_in(up, offset);
     261                 :            : }
     262                 :            : 
     263                 :            : static inline void serial_port_out(struct uart_port *up, int offset, int value)
     264                 :            : {
     265                 :          0 :         up->serial_out(up, offset, value);
     266                 :            : }
     267                 :            : 
     268                 :            : /**
     269                 :            :  * enum uart_pm_state - power states for UARTs
     270                 :            :  * @UART_PM_STATE_ON: UART is powered, up and operational
     271                 :            :  * @UART_PM_STATE_OFF: UART is powered off
     272                 :            :  * @UART_PM_STATE_UNDEFINED: sentinel
     273                 :            :  */
     274                 :            : enum uart_pm_state {
     275                 :            :         UART_PM_STATE_ON = 0,
     276                 :            :         UART_PM_STATE_OFF = 3, /* number taken from ACPI */
     277                 :            :         UART_PM_STATE_UNDEFINED,
     278                 :            : };
     279                 :            : 
     280                 :            : /*
     281                 :            :  * This is the state information which is persistent across opens.
     282                 :            :  */
     283                 :            : struct uart_state {
     284                 :            :         struct tty_port         port;
     285                 :            : 
     286                 :            :         enum uart_pm_state      pm_state;
     287                 :            :         struct circ_buf         xmit;
     288                 :            : 
     289                 :            :         atomic_t                refcount;
     290                 :            :         wait_queue_head_t       remove_wait;
     291                 :            :         struct uart_port        *uart_port;
     292                 :            : };
     293                 :            : 
     294                 :            : #define UART_XMIT_SIZE  PAGE_SIZE
     295                 :            : 
     296                 :            : 
     297                 :            : /* number of characters left in xmit buffer before we ask for more */
     298                 :            : #define WAKEUP_CHARS            256
     299                 :            : 
     300                 :            : struct module;
     301                 :            : struct tty_driver;
     302                 :            : 
     303                 :            : struct uart_driver {
     304                 :            :         struct module           *owner;
     305                 :            :         const char              *driver_name;
     306                 :            :         const char              *dev_name;
     307                 :            :         int                      major;
     308                 :            :         int                      minor;
     309                 :            :         int                      nr;
     310                 :            :         struct console          *cons;
     311                 :            : 
     312                 :            :         /*
     313                 :            :          * these are private; the low level driver should not
     314                 :            :          * touch these; they should be initialised to NULL
     315                 :            :          */
     316                 :            :         struct uart_state       *state;
     317                 :            :         struct tty_driver       *tty_driver;
     318                 :            : };
     319                 :            : 
     320                 :            : void uart_write_wakeup(struct uart_port *port);
     321                 :            : 
     322                 :            : /*
     323                 :            :  * Baud rate helpers.
     324                 :            :  */
     325                 :            : void uart_update_timeout(struct uart_port *port, unsigned int cflag,
     326                 :            :                          unsigned int baud);
     327                 :            : unsigned int uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
     328                 :            :                                 struct ktermios *old, unsigned int min,
     329                 :            :                                 unsigned int max);
     330                 :            : unsigned int uart_get_divisor(struct uart_port *port, unsigned int baud);
     331                 :            : 
     332                 :            : /* Base timer interval for polling */
     333                 :            : static inline int uart_poll_timeout(struct uart_port *port)
     334                 :            : {
     335                 :          0 :         int timeout = port->timeout;
     336                 :            : 
     337                 :          0 :         return timeout > 6 ? (timeout / 2 - 2) : 1;
     338                 :            : }
     339                 :            : 
     340                 :            : /*
     341                 :            :  * Console helpers.
     342                 :            :  */
     343                 :            : struct earlycon_device {
     344                 :            :         struct console *con;
     345                 :            :         struct uart_port port;
     346                 :            :         char options[16];               /* e.g., 115200n8 */
     347                 :            :         unsigned int baud;
     348                 :            : };
     349                 :            : 
     350                 :            : struct earlycon_id {
     351                 :            :         char    name[15];
     352                 :            :         char    name_term;      /* In case compiler didn't '\0' term name */
     353                 :            :         char    compatible[128];
     354                 :            :         int     (*setup)(struct earlycon_device *, const char *options);
     355                 :            : };
     356                 :            : 
     357                 :            : extern const struct earlycon_id *__earlycon_table[];
     358                 :            : extern const struct earlycon_id *__earlycon_table_end[];
     359                 :            : 
     360                 :            : #if defined(CONFIG_SERIAL_EARLYCON) && !defined(MODULE)
     361                 :            : #define EARLYCON_USED_OR_UNUSED __used
     362                 :            : #else
     363                 :            : #define EARLYCON_USED_OR_UNUSED __maybe_unused
     364                 :            : #endif
     365                 :            : 
     366                 :            : #define _OF_EARLYCON_DECLARE(_name, compat, fn, unique_id)              \
     367                 :            :         static const struct earlycon_id unique_id                       \
     368                 :            :              EARLYCON_USED_OR_UNUSED __initconst                        \
     369                 :            :                 = { .name = __stringify(_name),                         \
     370                 :            :                     .compatible = compat,                               \
     371                 :            :                     .setup = fn  };                                     \
     372                 :            :         static const struct earlycon_id EARLYCON_USED_OR_UNUSED         \
     373                 :            :                 __section(__earlycon_table)                             \
     374                 :            :                 * const __PASTE(__p, unique_id) = &unique_id
     375                 :            : 
     376                 :            : #define OF_EARLYCON_DECLARE(_name, compat, fn)                          \
     377                 :            :         _OF_EARLYCON_DECLARE(_name, compat, fn,                         \
     378                 :            :                              __UNIQUE_ID(__earlycon_##_name))
     379                 :            : 
     380                 :            : #define EARLYCON_DECLARE(_name, fn)     OF_EARLYCON_DECLARE(_name, "", fn)
     381                 :            : 
     382                 :            : extern int of_setup_earlycon(const struct earlycon_id *match,
     383                 :            :                              unsigned long node,
     384                 :            :                              const char *options);
     385                 :            : 
     386                 :            : #ifdef CONFIG_SERIAL_EARLYCON
     387                 :            : extern bool earlycon_acpi_spcr_enable __initdata;
     388                 :            : int setup_earlycon(char *buf);
     389                 :            : #else
     390                 :            : static const bool earlycon_acpi_spcr_enable EARLYCON_USED_OR_UNUSED;
     391                 :            : static inline int setup_earlycon(char *buf) { return 0; }
     392                 :            : #endif
     393                 :            : 
     394                 :            : struct uart_port *uart_get_console(struct uart_port *ports, int nr,
     395                 :            :                                    struct console *c);
     396                 :            : int uart_parse_earlycon(char *p, unsigned char *iotype, resource_size_t *addr,
     397                 :            :                         char **options);
     398                 :            : void uart_parse_options(const char *options, int *baud, int *parity, int *bits,
     399                 :            :                         int *flow);
     400                 :            : int uart_set_options(struct uart_port *port, struct console *co, int baud,
     401                 :            :                      int parity, int bits, int flow);
     402                 :            : struct tty_driver *uart_console_device(struct console *co, int *index);
     403                 :            : void uart_console_write(struct uart_port *port, const char *s,
     404                 :            :                         unsigned int count,
     405                 :            :                         void (*putchar)(struct uart_port *, int));
     406                 :            : 
     407                 :            : /*
     408                 :            :  * Port/driver registration/removal
     409                 :            :  */
     410                 :            : int uart_register_driver(struct uart_driver *uart);
     411                 :            : void uart_unregister_driver(struct uart_driver *uart);
     412                 :            : int uart_add_one_port(struct uart_driver *reg, struct uart_port *port);
     413                 :            : int uart_remove_one_port(struct uart_driver *reg, struct uart_port *port);
     414                 :            : int uart_match_port(struct uart_port *port1, struct uart_port *port2);
     415                 :            : 
     416                 :            : /*
     417                 :            :  * Power Management
     418                 :            :  */
     419                 :            : int uart_suspend_port(struct uart_driver *reg, struct uart_port *port);
     420                 :            : int uart_resume_port(struct uart_driver *reg, struct uart_port *port);
     421                 :            : 
     422                 :            : #define uart_circ_empty(circ)           ((circ)->head == (circ)->tail)
     423                 :            : #define uart_circ_clear(circ)           ((circ)->head = (circ)->tail = 0)
     424                 :            : 
     425                 :            : #define uart_circ_chars_pending(circ)   \
     426                 :            :         (CIRC_CNT((circ)->head, (circ)->tail, UART_XMIT_SIZE))
     427                 :            : 
     428                 :            : #define uart_circ_chars_free(circ)      \
     429                 :            :         (CIRC_SPACE((circ)->head, (circ)->tail, UART_XMIT_SIZE))
     430                 :            : 
     431                 :            : static inline int uart_tx_stopped(struct uart_port *port)
     432                 :            : {
     433                 :          3 :         struct tty_struct *tty = port->state->port.tty;
     434                 :          3 :         if ((tty && tty->stopped) || port->hw_stopped)
     435                 :            :                 return 1;
     436                 :            :         return 0;
     437                 :            : }
     438                 :            : 
     439                 :            : static inline bool uart_cts_enabled(struct uart_port *uport)
     440                 :            : {
     441                 :            :         return !!(uport->status & UPSTAT_CTS_ENABLE);
     442                 :            : }
     443                 :            : 
     444                 :            : static inline bool uart_softcts_mode(struct uart_port *uport)
     445                 :            : {
     446                 :            :         upstat_t mask = UPSTAT_CTS_ENABLE | UPSTAT_AUTOCTS;
     447                 :            : 
     448                 :          3 :         return ((uport->status & mask) == UPSTAT_CTS_ENABLE);
     449                 :            : }
     450                 :            : 
     451                 :            : /*
     452                 :            :  * The following are helper functions for the low level drivers.
     453                 :            :  */
     454                 :            : 
     455                 :            : extern void uart_handle_dcd_change(struct uart_port *uport,
     456                 :            :                 unsigned int status);
     457                 :            : extern void uart_handle_cts_change(struct uart_port *uport,
     458                 :            :                 unsigned int status);
     459                 :            : 
     460                 :            : extern void uart_insert_char(struct uart_port *port, unsigned int status,
     461                 :            :                  unsigned int overrun, unsigned int ch, unsigned int flag);
     462                 :            : 
     463                 :            : #if defined(SUPPORT_SYSRQ) && defined(CONFIG_MAGIC_SYSRQ_SERIAL)
     464                 :            : static inline int
     465                 :          1 : uart_handle_sysrq_char(struct uart_port *port, unsigned int ch)
     466                 :            : {
     467                 :          1 :         if (port->sysrq) {
     468                 :          0 :                 if (ch && time_before(jiffies, port->sysrq)) {
     469                 :          0 :                         handle_sysrq(ch);
     470                 :          0 :                         port->sysrq = 0;
     471                 :          0 :                         return 1;
     472                 :            :                 }
     473                 :          0 :                 port->sysrq = 0;
     474                 :            :         }
     475                 :            :         return 0;
     476                 :            : }
     477                 :            : static inline int
     478                 :            : uart_prepare_sysrq_char(struct uart_port *port, unsigned int ch)
     479                 :            : {
     480                 :          0 :         if (port->sysrq) {
     481                 :          0 :                 if (ch && time_before(jiffies, port->sysrq)) {
     482                 :          0 :                         port->sysrq_ch = ch;
     483                 :          0 :                         port->sysrq = 0;
     484                 :            :                         return 1;
     485                 :            :                 }
     486                 :          0 :                 port->sysrq = 0;
     487                 :            :         }
     488                 :            :         return 0;
     489                 :            : }
     490                 :            : static inline void
     491                 :          0 : uart_unlock_and_check_sysrq(struct uart_port *port, unsigned long irqflags)
     492                 :            : {
     493                 :            :         int sysrq_ch;
     494                 :            : 
     495                 :          0 :         sysrq_ch = port->sysrq_ch;
     496                 :          0 :         port->sysrq_ch = 0;
     497                 :            : 
     498                 :            :         spin_unlock_irqrestore(&port->lock, irqflags);
     499                 :            : 
     500                 :          0 :         if (sysrq_ch)
     501                 :          0 :                 handle_sysrq(sysrq_ch);
     502                 :          0 : }
     503                 :            : #else
     504                 :            : static inline int
     505                 :            : uart_handle_sysrq_char(struct uart_port *port, unsigned int ch) { return 0; }
     506                 :            : static inline int
     507                 :            : uart_prepare_sysrq_char(struct uart_port *port, unsigned int ch) { return 0; }
     508                 :            : static inline void
     509                 :            : uart_unlock_and_check_sysrq(struct uart_port *port, unsigned long irqflags)
     510                 :            : {
     511                 :            :         spin_unlock_irqrestore(&port->lock, irqflags);
     512                 :            : }
     513                 :            : #endif
     514                 :            : 
     515                 :            : /*
     516                 :            :  * We do the SysRQ and SAK checking like this...
     517                 :            :  */
     518                 :          0 : static inline int uart_handle_break(struct uart_port *port)
     519                 :            : {
     520                 :          0 :         struct uart_state *state = port->state;
     521                 :            : 
     522                 :          0 :         if (port->handle_break)
     523                 :          0 :                 port->handle_break(port);
     524                 :            : 
     525                 :            : #ifdef SUPPORT_SYSRQ
     526                 :          0 :         if (port->cons && port->cons->index == port->line) {
     527                 :          0 :                 if (!port->sysrq) {
     528                 :          0 :                         port->sysrq = jiffies + HZ*5;
     529                 :          0 :                         return 1;
     530                 :            :                 }
     531                 :          0 :                 port->sysrq = 0;
     532                 :            :         }
     533                 :            : #endif
     534                 :          0 :         if (port->flags & UPF_SAK)
     535                 :          0 :                 do_SAK(state->port.tty);
     536                 :            :         return 0;
     537                 :            : }
     538                 :            : 
     539                 :            : /*
     540                 :            :  *      UART_ENABLE_MS - determine if port should enable modem status irqs
     541                 :            :  */
     542                 :            : #define UART_ENABLE_MS(port,cflag)      ((port)->flags & UPF_HARDPPS_CD || \
     543                 :            :                                          (cflag) & CRTSCTS || \
     544                 :            :                                          !((cflag) & CLOCAL))
     545                 :            : 
     546                 :            : void uart_get_rs485_mode(struct device *dev, struct serial_rs485 *rs485conf);
     547                 :            : #endif /* LINUX_SERIAL_CORE_H */