serial_core.h 15.6 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
/*
 *  linux/drivers/char/serial_core.h
 *
 *  Copyright (C) 2000 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
 */
#ifndef LINUX_SERIAL_CORE_H
#define LINUX_SERIAL_CORE_H


24
#include <linux/compiler.h>
Linus Torvalds's avatar
Linus Torvalds committed
25 26 27 28 29
#include <linux/interrupt.h>
#include <linux/circ_buf.h>
#include <linux/spinlock.h>
#include <linux/sched.h>
#include <linux/tty.h>
30
#include <linux/mutex.h>
31
#include <linux/sysrq.h>
32
#include <uapi/linux/serial_core.h>
Linus Torvalds's avatar
Linus Torvalds committed
33

34 35 36 37
#ifdef CONFIG_SERIAL_CORE_CONSOLE
#define uart_console(port) \
	((port)->cons && (port)->cons->index == (port)->line)
#else
38
#define uart_console(port)      ({ (void)port; 0; })
39 40
#endif

Linus Torvalds's avatar
Linus Torvalds committed
41 42 43 44 45
struct uart_port;
struct serial_struct;
struct device;

/*
46 47
 * This structure describes all the operations that can be done on the
 * physical hardware.  See Documentation/serial/driver for details.
Linus Torvalds's avatar
Linus Torvalds committed
48 49 50 51 52
 */
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 *);
53 54
	void		(*stop_tx)(struct uart_port *);
	void		(*start_tx)(struct uart_port *);
55 56
	void		(*throttle)(struct uart_port *);
	void		(*unthrottle)(struct uart_port *);
Linus Torvalds's avatar
Linus Torvalds committed
57 58 59 60 61 62
	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 *);
63
	void		(*flush_buffer)(struct uart_port *);
64 65
	void		(*set_termios)(struct uart_port *, struct ktermios *new,
				       struct ktermios *old);
66
	void		(*set_ldisc)(struct uart_port *, struct ktermios *);
Linus Torvalds's avatar
Linus Torvalds committed
67 68 69 70 71 72
	void		(*pm)(struct uart_port *, unsigned int state,
			      unsigned int oldstate);

	/*
	 * Return a string describing the type of the port
	 */
73
	const char	*(*type)(struct uart_port *);
Linus Torvalds's avatar
Linus Torvalds committed
74 75 76 77 78 79 80 81 82 83 84 85 86 87 88

	/*
	 * 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);
89
#ifdef CONFIG_CONSOLE_POLL
90
	int		(*poll_init)(struct uart_port *);
91
	void		(*poll_put_char)(struct uart_port *, unsigned char);
92 93
	int		(*poll_get_char)(struct uart_port *);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
94 95
};

96
#define NO_POLL_CHAR		0x00ff0000
Linus Torvalds's avatar
Linus Torvalds committed
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
#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;
};

114
typedef unsigned int __bitwise__ upf_t;
115
typedef unsigned int __bitwise__ upstat_t;
116

Linus Torvalds's avatar
Linus Torvalds committed
117 118
struct uart_port {
	spinlock_t		lock;			/* port lock */
119
	unsigned long		iobase;			/* in/out[bwl] */
Linus Torvalds's avatar
Linus Torvalds committed
120
	unsigned char __iomem	*membase;		/* read/write[bwl] */
121 122
	unsigned int		(*serial_in)(struct uart_port *, int);
	void			(*serial_out)(struct uart_port *, int, int);
123 124 125
	void			(*set_termios)(struct uart_port *,
				               struct ktermios *new,
				               struct ktermios *old);
126
	unsigned int		(*get_mctrl)(struct uart_port *);
127
	void			(*set_mctrl)(struct uart_port *, unsigned int);
128 129
	int			(*startup)(struct uart_port *port);
	void			(*shutdown)(struct uart_port *port);
130 131
	void			(*throttle)(struct uart_port *port);
	void			(*unthrottle)(struct uart_port *port);
132
	int			(*handle_irq)(struct uart_port *);
133 134
	void			(*pm)(struct uart_port *, unsigned int state,
				      unsigned int old);
135
	void			(*handle_break)(struct uart_port *);
136 137
	int			(*rs485_config)(struct uart_port *,
						struct serial_rs485 *rs485);
Linus Torvalds's avatar
Linus Torvalds committed
138
	unsigned int		irq;			/* irq number */
139
	unsigned long		irqflags;		/* irq flags  */
Linus Torvalds's avatar
Linus Torvalds committed
140
	unsigned int		uartclk;		/* base uart clock */
141
	unsigned int		fifosize;		/* tx fifo size */
Linus Torvalds's avatar
Linus Torvalds committed
142 143 144
	unsigned char		x_char;			/* xon/xoff char */
	unsigned char		regshift;		/* reg offset shift */
	unsigned char		iotype;			/* io access style */
145
	unsigned char		unused1;
Linus Torvalds's avatar
Linus Torvalds committed
146

147 148
#define UPIO_PORT		(SERIAL_IO_PORT)	/* 8b I/O port access */
#define UPIO_HUB6		(SERIAL_IO_HUB6)	/* Hub6 ISA card */
149
#define UPIO_MEM		(SERIAL_IO_MEM)		/* driver-specific */
150 151 152 153
#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 */
154
#define UPIO_MEM16		(SERIAL_IO_MEM16)	/* 16b little endian */
Linus Torvalds's avatar
Linus Torvalds committed
155 156 157

	unsigned int		read_status_mask;	/* driver specific */
	unsigned int		ignore_status_mask;	/* driver specific */
Alan Cox's avatar
Alan Cox committed
158
	struct uart_state	*state;			/* pointer to parent state */
Linus Torvalds's avatar
Linus Torvalds committed
159 160 161
	struct uart_icount	icount;			/* statistics */

	struct console		*cons;			/* struct console, if any */
162
#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(SUPPORT_SYSRQ)
Linus Torvalds's avatar
Linus Torvalds committed
163 164 165
	unsigned long		sysrq;			/* sysrq timeout */
#endif

166
	/* flags must be updated while holding port mutex */
167 168
	upf_t			flags;

169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192
	/*
	 * 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
	 * except bit 15 (UPF_NO_TXEN_TEST) which is masked off.
	 * 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 */ )
193
#define UPF_NO_TXEN_TEST	((__force upf_t) (1 << 15))
194 195
#define UPF_MAGIC_MULTIPLIER	((__force upf_t) ASYNC_MAGIC_MULTIPLIER /* 16 */ )

196 197 198 199
/* 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))
200 201
/* Port has hardware-assisted s/w flow control */
#define UPF_SOFT_FLOW		((__force upf_t) (1 << 22))
202 203
#define UPF_CONS_FLOW		((__force upf_t) (1 << 23))
#define UPF_SHARE_IRQ		((__force upf_t) (1 << 24))
204
#define UPF_EXAR_EFR		((__force upf_t) (1 << 25))
205
#define UPF_BUG_THRE		((__force upf_t) (1 << 26))
206 207
/* The exact UART type is known and should not be probed.  */
#define UPF_FIXED_TYPE		((__force upf_t) (1 << 27))
208
#define UPF_BOOT_AUTOCONF	((__force upf_t) (1 << 28))
209
#define UPF_FIXED_PORT		((__force upf_t) (1 << 29))
210
#define UPF_DEAD		((__force upf_t) (1 << 30))
211 212
#define UPF_IOREMAP		((__force upf_t) (1 << 31))

213 214
#define __UPF_CHANGE_MASK	0x17fff
#define UPF_CHANGE_MASK		((__force upf_t) __UPF_CHANGE_MASK)
215
#define UPF_USR_MASK		((__force upf_t) (UPF_SPD_MASK|UPF_LOW_LATENCY))
Linus Torvalds's avatar
Linus Torvalds committed
216

217 218 219 220
#if __UPF_CHANGE_MASK > ASYNC_FLAGS
#error Change mask not equivalent to userspace-visible bit defines
#endif

221 222 223 224
	/*
	 * Must hold termios_rwsem, port mutex and port lock to change;
	 * can hold any one lock to read.
	 */
225 226 227 228
	upstat_t		status;

#define UPSTAT_CTS_ENABLE	((__force upstat_t) (1 << 0))
#define UPSTAT_DCD_ENABLE	((__force upstat_t) (1 << 1))
229 230 231
#define UPSTAT_AUTORTS		((__force upstat_t) (1 << 2))
#define UPSTAT_AUTOCTS		((__force upstat_t) (1 << 3))
#define UPSTAT_AUTOXOFF		((__force upstat_t) (1 << 4))
232

233
	int			hw_stopped;		/* sw-assisted CTS flow state */
Linus Torvalds's avatar
Linus Torvalds committed
234 235 236
	unsigned int		mctrl;			/* current modem ctrl settings */
	unsigned int		timeout;		/* character-based timeout */
	unsigned int		type;			/* port type */
237
	const struct uart_ops	*ops;
Linus Torvalds's avatar
Linus Torvalds committed
238 239
	unsigned int		custom_divisor;
	unsigned int		line;			/* port index */
240
	unsigned int		minor;
241
	resource_size_t		mapbase;		/* for ioremap */
242
	resource_size_t		mapsize;
Linus Torvalds's avatar
Linus Torvalds committed
243 244
	struct device		*dev;			/* parent device */
	unsigned char		hub6;			/* this should be in the 8250 driver */
245
	unsigned char		suspended;
246
	unsigned char		irq_wake;
247
	unsigned char		unused[2];
248 249
	struct attribute_group	*attr_group;		/* port specific attributes */
	const struct attribute_group **tty_groups;	/* all attributes (serial core use only) */
250
	struct serial_rs485     rs485;
Marc St-Jean's avatar
Marc St-Jean committed
251
	void			*private_data;		/* generic platform data pointer */
Linus Torvalds's avatar
Linus Torvalds committed
252 253
};

254 255 256 257 258 259 260 261 262 263
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);
}

264 265 266 267 268 269 270 271 272 273 274 275
/**
 * 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,
};

Alan Cox's avatar
Alan Cox committed
276 277 278 279
/*
 * This is the state information which is persistent across opens.
 */
struct uart_state {
Alan Cox's avatar
Alan Cox committed
280
	struct tty_port		port;
Alan Cox's avatar
Alan Cox committed
281

282
	enum uart_pm_state	pm_state;
Linus Torvalds's avatar
Linus Torvalds committed
283 284
	struct circ_buf		xmit;

285 286
	atomic_t		refcount;
	wait_queue_head_t	remove_wait;
Alan Cox's avatar
Alan Cox committed
287
	struct uart_port	*uart_port;
288 289 290 291 292
};

#define UART_XMIT_SIZE	PAGE_SIZE


Linus Torvalds's avatar
Linus Torvalds committed
293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
/* 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);
323 324
unsigned int uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
				struct ktermios *old, unsigned int min,
Linus Torvalds's avatar
Linus Torvalds committed
325 326 327
				unsigned int max);
unsigned int uart_get_divisor(struct uart_port *port, unsigned int baud);

328 329 330 331 332 333 334 335
/* 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;
}

Linus Torvalds's avatar
Linus Torvalds committed
336 337 338
/*
 * Console helpers.
 */
339 340 341 342 343 344 345
struct earlycon_device {
	struct console *con;
	struct uart_port port;
	char options[16];		/* e.g., 115200n8 */
	unsigned int baud;
};

346 347
struct earlycon_id {
	char	name[16];
348
	char	compatible[128];
349
	int	(*setup)(struct earlycon_device *, const char *options);
350
} __aligned(32);
351

352 353 354
extern const struct earlycon_id __earlycon_table[];
extern const struct earlycon_id __earlycon_table_end[];

355 356 357 358 359 360
#if defined(CONFIG_SERIAL_EARLYCON) && !defined(MODULE)
#define EARLYCON_USED_OR_UNUSED	__used
#else
#define EARLYCON_USED_OR_UNUSED	__maybe_unused
#endif

361 362
#define OF_EARLYCON_DECLARE(_name, compat, fn)				\
	static const struct earlycon_id __UNIQUE_ID(__earlycon_##_name)	\
363
	     EARLYCON_USED_OR_UNUSED __section(__earlycon_table)	\
364 365 366 367 368 369
		= { .name = __stringify(_name),				\
		    .compatible = compat,				\
		    .setup = fn  }

#define EARLYCON_DECLARE(_name, fn)	OF_EARLYCON_DECLARE(_name, "", fn)

370
extern int setup_earlycon(char *buf);
371
extern int of_setup_earlycon(const struct earlycon_id *match,
372
			     unsigned long node,
373
			     const char *options);
374

Linus Torvalds's avatar
Linus Torvalds committed
375 376
struct uart_port *uart_get_console(struct uart_port *ports, int nr,
				   struct console *c);
377 378
int uart_parse_earlycon(char *p, unsigned char *iotype, unsigned long *addr,
			char **options);
Linus Torvalds's avatar
Linus Torvalds committed
379 380 381 382 383
void uart_parse_options(char *options, int *baud, int *parity, int *bits,
			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);
384 385 386
void uart_console_write(struct uart_port *port, const char *s,
			unsigned int count,
			void (*putchar)(struct uart_port *, int));
Linus Torvalds's avatar
Linus Torvalds committed
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411

/*
 * 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))

412 413
static inline int uart_tx_stopped(struct uart_port *port)
{
Alan Cox's avatar
Alan Cox committed
414
	struct tty_struct *tty = port->state->port.tty;
415
	if (tty->stopped || port->hw_stopped)
416 417 418
		return 1;
	return 0;
}
Linus Torvalds's avatar
Linus Torvalds committed
419

420 421
static inline bool uart_cts_enabled(struct uart_port *uport)
{
422
	return !!(uport->status & UPSTAT_CTS_ENABLE);
423 424
}

425 426 427 428 429 430 431
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);
}

Linus Torvalds's avatar
Linus Torvalds committed
432 433 434
/*
 * The following are helper functions for the low level drivers.
 */
435 436 437 438 439 440 441 442 443 444

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);

#ifdef SUPPORT_SYSRQ
Linus Torvalds's avatar
Linus Torvalds committed
445
static inline int
446
uart_handle_sysrq_char(struct uart_port *port, unsigned int ch)
Linus Torvalds's avatar
Linus Torvalds committed
447 448 449
{
	if (port->sysrq) {
		if (ch && time_before(jiffies, port->sysrq)) {
450
			handle_sysrq(ch);
Linus Torvalds's avatar
Linus Torvalds committed
451 452 453 454 455 456 457
			port->sysrq = 0;
			return 1;
		}
		port->sysrq = 0;
	}
	return 0;
}
458 459
#else
#define uart_handle_sysrq_char(port,ch) ({ (void)port; 0; })
460
#endif
Linus Torvalds's avatar
Linus Torvalds committed
461 462 463 464 465 466

/*
 * We do the SysRQ and SAK checking like this...
 */
static inline int uart_handle_break(struct uart_port *port)
{
Alan Cox's avatar
Alan Cox committed
467
	struct uart_state *state = port->state;
468 469 470 471

	if (port->handle_break)
		port->handle_break(port);

Linus Torvalds's avatar
Linus Torvalds committed
472 473 474 475 476 477 478 479 480
#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
481
	if (port->flags & UPF_SAK)
Alan Cox's avatar
Alan Cox committed
482
		do_SAK(state->port.tty);
Linus Torvalds's avatar
Linus Torvalds committed
483 484 485 486 487 488 489 490 491 492 493
	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))

#endif /* LINUX_SERIAL_CORE_H */