serial_core.c 74.7 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0+
L
Linus Torvalds 已提交
2 3 4 5 6 7 8 9 10 11
/*
 *  Driver core for serial ports
 *
 *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
 *
 *  Copyright 1999 ARM Limited
 *  Copyright (C) 2000-2001 Deep Blue Solutions Ltd.
 */
#include <linux/module.h>
#include <linux/tty.h>
J
Jiri Slaby 已提交
12
#include <linux/tty_flip.h>
L
Linus Torvalds 已提交
13
#include <linux/slab.h>
14
#include <linux/sched/signal.h>
L
Linus Torvalds 已提交
15 16
#include <linux/init.h>
#include <linux/console.h>
17
#include <linux/of.h>
18 19
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
L
Linus Torvalds 已提交
20 21
#include <linux/device.h>
#include <linux/serial.h> /* for serial_state and serial_icounter_struct */
22
#include <linux/serial_core.h>
L
Linus Torvalds 已提交
23
#include <linux/delay.h>
24
#include <linux/mutex.h>
L
Linus Torvalds 已提交
25

26
#include <linux/irq.h>
27
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
28 29 30 31

/*
 * This is used to lock changes in serial line configuration.
 */
32
static DEFINE_MUTEX(port_mutex);
L
Linus Torvalds 已提交
33

I
Ingo Molnar 已提交
34 35 36 37 38 39
/*
 * lockdep: port->lock is initialized in two places, but we
 *          want only one lock-class:
 */
static struct lock_class_key port_lock_key;

L
Linus Torvalds 已提交
40 41
#define HIGH_BITS_OFFSET	((sizeof(long)-sizeof(int))*8)

42
static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
43
					struct ktermios *old_termios);
44
static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
45 46
static void uart_change_pm(struct uart_state *state,
			   enum uart_pm_state pm_state);
L
Linus Torvalds 已提交
47

J
Jiri Slaby 已提交
48 49
static void uart_port_shutdown(struct tty_port *port);

50 51
static int uart_dcd_enabled(struct uart_port *uport)
{
52
	return !!(uport->status & UPSTAT_DCD_ENABLE);
53 54
}

55 56 57 58 59 60 61 62 63
static inline struct uart_port *uart_port_ref(struct uart_state *state)
{
	if (atomic_add_unless(&state->refcount, 1, 0))
		return state->uart_port;
	return NULL;
}

static inline void uart_port_deref(struct uart_port *uport)
{
64
	if (atomic_dec_and_test(&uport->state->refcount))
65 66 67 68 69 70 71 72 73 74 75 76 77 78
		wake_up(&uport->state->remove_wait);
}

#define uart_port_lock(state, flags)					\
	({								\
		struct uart_port *__uport = uart_port_ref(state);	\
		if (__uport)						\
			spin_lock_irqsave(&__uport->lock, flags);	\
		__uport;						\
	})

#define uart_port_unlock(uport, flags)					\
	({								\
		struct uart_port *__uport = uport;			\
79
		if (__uport) {						\
80
			spin_unlock_irqrestore(&__uport->lock, flags);	\
81 82
			uart_port_deref(__uport);			\
		}							\
83 84
	})

85 86
static inline struct uart_port *uart_port_check(struct uart_state *state)
{
87
	lockdep_assert_held(&state->port.mutex);
88 89 90
	return state->uart_port;
}

L
Linus Torvalds 已提交
91 92 93 94 95 96
/*
 * This routine is used by the interrupt handler to schedule processing in
 * the software interrupt portion of the driver.
 */
void uart_write_wakeup(struct uart_port *port)
{
A
Alan Cox 已提交
97
	struct uart_state *state = port->state;
98 99 100 101
	/*
	 * This means you called this function _after_ the port was
	 * closed.  No cookie for you.
	 */
A
Alan Cox 已提交
102
	BUG_ON(!state);
103
	tty_port_tty_wakeup(&state->port);
L
Linus Torvalds 已提交
104 105 106 107 108
}

static void uart_stop(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
109
	struct uart_port *port;
L
Linus Torvalds 已提交
110 111
	unsigned long flags;

112 113 114 115
	port = uart_port_lock(state, flags);
	if (port)
		port->ops->stop_tx(port);
	uart_port_unlock(port, flags);
L
Linus Torvalds 已提交
116 117 118 119 120
}

static void __uart_start(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
A
Alan Cox 已提交
121
	struct uart_port *port = state->uart_port;
L
Linus Torvalds 已提交
122

123
	if (port && !uart_tx_stopped(port))
124
		port->ops->start_tx(port);
L
Linus Torvalds 已提交
125 126 127 128 129
}

static void uart_start(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
130
	struct uart_port *port;
L
Linus Torvalds 已提交
131 132
	unsigned long flags;

133
	port = uart_port_lock(state, flags);
L
Linus Torvalds 已提交
134
	__uart_start(tty);
135
	uart_port_unlock(port, flags);
L
Linus Torvalds 已提交
136 137
}

138
static void
L
Linus Torvalds 已提交
139 140 141 142 143 144 145 146 147 148 149 150 151
uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
{
	unsigned long flags;
	unsigned int old;

	spin_lock_irqsave(&port->lock, flags);
	old = port->mctrl;
	port->mctrl = (old & ~clear) | set;
	if (old != port->mctrl)
		port->ops->set_mctrl(port, port->mctrl);
	spin_unlock_irqrestore(&port->lock, flags);
}

152 153
#define uart_set_mctrl(port, set)	uart_update_mctrl(port, set, 0)
#define uart_clear_mctrl(port, clear)	uart_update_mctrl(port, 0, clear)
L
Linus Torvalds 已提交
154

155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
static void uart_port_dtr_rts(struct uart_port *uport, int raise)
{
	int rs485_on = uport->rs485_config &&
		(uport->rs485.flags & SER_RS485_ENABLED);
	int RTS_after_send = !!(uport->rs485.flags & SER_RS485_RTS_AFTER_SEND);

	if (raise) {
		if (rs485_on && !RTS_after_send) {
			uart_set_mctrl(uport, TIOCM_DTR);
			uart_clear_mctrl(uport, TIOCM_RTS);
		} else {
			uart_set_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
		}
	} else {
		unsigned int clear = TIOCM_DTR;

		clear |= (!rs485_on || !RTS_after_send) ? TIOCM_RTS : 0;
		uart_clear_mctrl(uport, clear);
	}
}

L
Linus Torvalds 已提交
176 177
/*
 * Startup the port.  This will be called once per open.  All calls
A
Alan Cox 已提交
178
 * will be serialised by the per-port mutex.
L
Linus Torvalds 已提交
179
 */
180 181
static int uart_port_startup(struct tty_struct *tty, struct uart_state *state,
		int init_hw)
L
Linus Torvalds 已提交
182
{
183
	struct uart_port *uport = uart_port_check(state);
L
Linus Torvalds 已提交
184
	unsigned long page;
185
	unsigned long flags = 0;
L
Linus Torvalds 已提交
186 187
	int retval = 0;

188
	if (uport->type == PORT_UNKNOWN)
189
		return 1;
L
Linus Torvalds 已提交
190

191 192 193 194 195
	/*
	 * Make sure the device is in D0 state.
	 */
	uart_change_pm(state, UART_PM_STATE_ON);

L
Linus Torvalds 已提交
196 197 198 199
	/*
	 * Initialise and allocate the transmit and temporary
	 * buffer.
	 */
200 201 202
	page = get_zeroed_page(GFP_KERNEL);
	if (!page)
		return -ENOMEM;
L
Linus Torvalds 已提交
203

204 205
	uart_port_lock(state, flags);
	if (!state->xmit.buf) {
A
Alan Cox 已提交
206 207
		state->xmit.buf = (unsigned char *) page;
		uart_circ_clear(&state->xmit);
208 209
	} else {
		free_page(page);
L
Linus Torvalds 已提交
210
	}
211
	uart_port_unlock(uport, flags);
L
Linus Torvalds 已提交
212

213
	retval = uport->ops->startup(uport);
L
Linus Torvalds 已提交
214
	if (retval == 0) {
215
		if (uart_console(uport) && uport->cons->cflag) {
216
			tty->termios.c_cflag = uport->cons->cflag;
217 218 219 220 221 222
			uport->cons->cflag = 0;
		}
		/*
		 * Initialise the hardware port settings.
		 */
		uart_change_speed(tty, state, NULL);
L
Linus Torvalds 已提交
223

P
Peter Hurley 已提交
224 225 226 227 228
		/*
		 * Setup the RTS and DTR signals once the
		 * port is open and ready to respond.
		 */
		if (init_hw && C_BAUD(tty))
229
			uart_port_dtr_rts(uport, 1);
L
Linus Torvalds 已提交
230 231
	}

232 233 234 235 236
	/*
	 * This is to allow setserial on this port. People may want to set
	 * port/irq/type and then reconfigure the port properly if it failed
	 * now.
	 */
L
Linus Torvalds 已提交
237
	if (retval && capable(CAP_SYS_ADMIN))
238 239 240 241 242 243 244 245 246 247 248
		return 1;

	return retval;
}

static int uart_startup(struct tty_struct *tty, struct uart_state *state,
		int init_hw)
{
	struct tty_port *port = &state->port;
	int retval;

249
	if (tty_port_initialized(port))
250 251 252
		return 0;

	retval = uart_port_startup(tty, state, init_hw);
253 254
	if (retval)
		set_bit(TTY_IO_ERROR, &tty->flags);
L
Linus Torvalds 已提交
255 256 257 258 259 260 261 262

	return retval;
}

/*
 * This routine will shutdown a serial port; interrupts are disabled, and
 * DTR is dropped if the hangup on close termio flag is on.  Calls to
 * uart_shutdown are serialised by the per-port semaphore.
263 264
 *
 * uport == NULL if uart_port has already been removed
L
Linus Torvalds 已提交
265
 */
266
static void uart_shutdown(struct tty_struct *tty, struct uart_state *state)
L
Linus Torvalds 已提交
267
{
268
	struct uart_port *uport = uart_port_check(state);
269
	struct tty_port *port = &state->port;
270
	unsigned long flags = 0;
L
Linus Torvalds 已提交
271 272

	/*
273
	 * Set the TTY IO error marker
L
Linus Torvalds 已提交
274
	 */
275 276
	if (tty)
		set_bit(TTY_IO_ERROR, &tty->flags);
L
Linus Torvalds 已提交
277

278 279 280
	if (tty_port_initialized(port)) {
		tty_port_set_initialized(port, 0);

281 282 283
		/*
		 * Turn off DTR and RTS early.
		 */
284
		if (uport && uart_console(uport) && tty)
285 286
			uport->cons->cflag = tty->termios.c_cflag;

P
Peter Hurley 已提交
287
		if (!tty || C_HUPCL(tty))
288
			uart_port_dtr_rts(uport, 0);
289

J
Jiri Slaby 已提交
290
		uart_port_shutdown(port);
291
	}
L
Linus Torvalds 已提交
292 293

	/*
294 295 296
	 * It's possible for shutdown to be called after suspend if we get
	 * a DCD drop (hangup) at just the right time.  Clear suspended bit so
	 * we don't try to resume a port that has been shutdown.
L
Linus Torvalds 已提交
297
	 */
298
	tty_port_set_suspended(port, 0);
L
Linus Torvalds 已提交
299 300 301 302

	/*
	 * Free the transmit buffer page.
	 */
303
	uart_port_lock(state, flags);
A
Alan Cox 已提交
304 305 306
	if (state->xmit.buf) {
		free_page((unsigned long)state->xmit.buf);
		state->xmit.buf = NULL;
L
Linus Torvalds 已提交
307
	}
308
	uart_port_unlock(uport, flags);
L
Linus Torvalds 已提交
309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338
}

/**
 *	uart_update_timeout - update per-port FIFO timeout.
 *	@port:  uart_port structure describing the port
 *	@cflag: termios cflag value
 *	@baud:  speed of the port
 *
 *	Set the port FIFO timeout value.  The @cflag value should
 *	reflect the actual hardware settings.
 */
void
uart_update_timeout(struct uart_port *port, unsigned int cflag,
		    unsigned int baud)
{
	unsigned int bits;

	/* byte size and parity */
	switch (cflag & CSIZE) {
	case CS5:
		bits = 7;
		break;
	case CS6:
		bits = 8;
		break;
	case CS7:
		bits = 9;
		break;
	default:
		bits = 10;
339
		break; /* CS8 */
L
Linus Torvalds 已提交
340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
	}

	if (cflag & CSTOPB)
		bits++;
	if (cflag & PARENB)
		bits++;

	/*
	 * The total number of bits to be transmitted in the fifo.
	 */
	bits = bits * port->fifosize;

	/*
	 * Figure the timeout to send the above number of bits.
	 * Add .02 seconds of slop
	 */
	port->timeout = (HZ * bits) / baud + HZ/50;
}

EXPORT_SYMBOL(uart_update_timeout);

/**
 *	uart_get_baud_rate - return baud rate for a particular port
 *	@port: uart_port structure describing the port in question.
 *	@termios: desired termios settings.
 *	@old: old termios (or NULL)
 *	@min: minimum acceptable baud rate
 *	@max: maximum acceptable baud rate
 *
 *	Decode the termios structure into a numeric baud rate,
 *	taking account of the magic 38400 baud rate (with spd_*
 *	flags), and mapping the %B0 rate to 9600 baud.
 *
 *	If the new baud rate is invalid, try the old termios setting.
 *	If it's still invalid, we try 9600 baud.
 *
 *	Update the @termios structure to reflect the baud rate
377 378
 *	we're actually going to be using. Don't do this for the case
 *	where B0 is requested ("hang up").
L
Linus Torvalds 已提交
379 380
 */
unsigned int
A
Alan Cox 已提交
381 382
uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
		   struct ktermios *old, unsigned int min, unsigned int max)
L
Linus Torvalds 已提交
383
{
384 385 386
	unsigned int try;
	unsigned int baud;
	unsigned int altbaud;
387
	int hung_up = 0;
388
	upf_t flags = port->flags & UPF_SPD_MASK;
L
Linus Torvalds 已提交
389

390 391
	switch (flags) {
	case UPF_SPD_HI:
L
Linus Torvalds 已提交
392
		altbaud = 57600;
393 394
		break;
	case UPF_SPD_VHI:
L
Linus Torvalds 已提交
395
		altbaud = 115200;
396 397
		break;
	case UPF_SPD_SHI:
L
Linus Torvalds 已提交
398
		altbaud = 230400;
399 400
		break;
	case UPF_SPD_WARP:
L
Linus Torvalds 已提交
401
		altbaud = 460800;
402 403 404 405 406
		break;
	default:
		altbaud = 38400;
		break;
	}
L
Linus Torvalds 已提交
407 408 409 410 411 412 413 414

	for (try = 0; try < 2; try++) {
		baud = tty_termios_baud_rate(termios);

		/*
		 * The spd_hi, spd_vhi, spd_shi, spd_warp kludge...
		 * Die! Die! Die!
		 */
415
		if (try == 0 && baud == 38400)
L
Linus Torvalds 已提交
416 417 418 419 420
			baud = altbaud;

		/*
		 * Special case: B0 rate.
		 */
421 422
		if (baud == 0) {
			hung_up = 1;
L
Linus Torvalds 已提交
423
			baud = 9600;
424
		}
L
Linus Torvalds 已提交
425 426 427 428 429 430 431 432 433 434

		if (baud >= min && baud <= max)
			return baud;

		/*
		 * Oops, the quotient was zero.  Try again with
		 * the old baud rate if possible.
		 */
		termios->c_cflag &= ~CBAUD;
		if (old) {
A
Alan Cox 已提交
435
			baud = tty_termios_baud_rate(old);
436 437 438
			if (!hung_up)
				tty_termios_encode_baud_rate(termios,
								baud, baud);
L
Linus Torvalds 已提交
439 440 441 442 443
			old = NULL;
			continue;
		}

		/*
444 445
		 * As a last resort, if the range cannot be met then clip to
		 * the nearest chip supported rate.
L
Linus Torvalds 已提交
446
		 */
447 448 449 450 451 452 453 454
		if (!hung_up) {
			if (baud <= min)
				tty_termios_encode_baud_rate(termios,
							min + 1, min + 1);
			else
				tty_termios_encode_baud_rate(termios,
							max - 1, max - 1);
		}
L
Linus Torvalds 已提交
455
	}
456 457
	/* Should never happen */
	WARN_ON(1);
L
Linus Torvalds 已提交
458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480
	return 0;
}

EXPORT_SYMBOL(uart_get_baud_rate);

/**
 *	uart_get_divisor - return uart clock divisor
 *	@port: uart_port structure describing the port.
 *	@baud: desired baud rate
 *
 *	Calculate the uart clock divisor for the port.
 */
unsigned int
uart_get_divisor(struct uart_port *port, unsigned int baud)
{
	unsigned int quot;

	/*
	 * Old custom speed handling.
	 */
	if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)
		quot = port->custom_divisor;
	else
481
		quot = DIV_ROUND_CLOSEST(port->uartclk, 16 * baud);
L
Linus Torvalds 已提交
482 483 484 485 486 487

	return quot;
}

EXPORT_SYMBOL(uart_get_divisor);

488
/* Caller holds port mutex */
489 490
static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
					struct ktermios *old_termios)
L
Linus Torvalds 已提交
491
{
492
	struct uart_port *uport = uart_port_check(state);
A
Alan Cox 已提交
493
	struct ktermios *termios;
494
	int hw_stopped;
L
Linus Torvalds 已提交
495 496 497 498 499

	/*
	 * If we have no tty, termios, or the port does not exist,
	 * then we can't set the parameters for this port.
	 */
500
	if (!tty || uport->type == PORT_UNKNOWN)
L
Linus Torvalds 已提交
501 502
		return;

503
	termios = &tty->termios;
504
	uport->ops->set_termios(uport, termios, old_termios);
L
Linus Torvalds 已提交
505 506

	/*
507
	 * Set modem status enables based on termios cflag
L
Linus Torvalds 已提交
508
	 */
509
	spin_lock_irq(&uport->lock);
L
Linus Torvalds 已提交
510
	if (termios->c_cflag & CRTSCTS)
511
		uport->status |= UPSTAT_CTS_ENABLE;
L
Linus Torvalds 已提交
512
	else
513
		uport->status &= ~UPSTAT_CTS_ENABLE;
L
Linus Torvalds 已提交
514 515

	if (termios->c_cflag & CLOCAL)
516
		uport->status &= ~UPSTAT_DCD_ENABLE;
L
Linus Torvalds 已提交
517
	else
518
		uport->status |= UPSTAT_DCD_ENABLE;
519 520 521 522 523 524 525 526 527 528 529 530

	/* reset sw-assisted CTS flow control based on (possibly) new mode */
	hw_stopped = uport->hw_stopped;
	uport->hw_stopped = uart_softcts_mode(uport) &&
				!(uport->ops->get_mctrl(uport) & TIOCM_CTS);
	if (uport->hw_stopped) {
		if (!hw_stopped)
			uport->ops->stop_tx(uport);
	} else {
		if (hw_stopped)
			__uart_start(tty);
	}
531
	spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
532 533
}

534
static int uart_put_char(struct tty_struct *tty, unsigned char c)
L
Linus Torvalds 已提交
535
{
536
	struct uart_state *state = tty->driver_data;
537
	struct uart_port *port;
538
	struct circ_buf *circ;
L
Linus Torvalds 已提交
539
	unsigned long flags;
540
	int ret = 0;
L
Linus Torvalds 已提交
541

542
	circ = &state->xmit;
L
Linus Torvalds 已提交
543
	if (!circ->buf)
544
		return 0;
L
Linus Torvalds 已提交
545

546 547
	port = uart_port_lock(state, flags);
	if (port && uart_circ_chars_free(circ) != 0) {
L
Linus Torvalds 已提交
548 549
		circ->buf[circ->head] = c;
		circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);
550
		ret = 1;
L
Linus Torvalds 已提交
551
	}
552
	uart_port_unlock(port, flags);
553
	return ret;
L
Linus Torvalds 已提交
554 555 556 557 558 559 560
}

static void uart_flush_chars(struct tty_struct *tty)
{
	uart_start(tty);
}

561 562
static int uart_write(struct tty_struct *tty,
					const unsigned char *buf, int count)
L
Linus Torvalds 已提交
563 564
{
	struct uart_state *state = tty->driver_data;
565 566
	struct uart_port *port;
	struct circ_buf *circ;
L
Linus Torvalds 已提交
567 568 569
	unsigned long flags;
	int c, ret = 0;

570 571 572 573
	/*
	 * This means you called this function _after_ the port was
	 * closed.  No cookie for you.
	 */
574
	if (!state) {
575 576 577 578
		WARN_ON(1);
		return -EL3HLT;
	}

A
Alan Cox 已提交
579
	circ = &state->xmit;
L
Linus Torvalds 已提交
580 581 582
	if (!circ->buf)
		return 0;

583 584
	port = uart_port_lock(state, flags);
	while (port) {
L
Linus Torvalds 已提交
585 586 587 588 589 590 591 592 593 594 595
		c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
		if (count < c)
			c = count;
		if (c <= 0)
			break;
		memcpy(circ->buf + circ->head, buf, c);
		circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
		buf += c;
		count -= c;
		ret += c;
	}
596 597

	__uart_start(tty);
598
	uart_port_unlock(port, flags);
L
Linus Torvalds 已提交
599 600 601 602 603 604
	return ret;
}

static int uart_write_room(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
605
	struct uart_port *port;
A
Alan Cox 已提交
606 607
	unsigned long flags;
	int ret;
L
Linus Torvalds 已提交
608

609
	port = uart_port_lock(state, flags);
A
Alan Cox 已提交
610
	ret = uart_circ_chars_free(&state->xmit);
611
	uart_port_unlock(port, flags);
A
Alan Cox 已提交
612
	return ret;
L
Linus Torvalds 已提交
613 614 615 616 617
}

static int uart_chars_in_buffer(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
618
	struct uart_port *port;
A
Alan Cox 已提交
619 620
	unsigned long flags;
	int ret;
L
Linus Torvalds 已提交
621

622
	port = uart_port_lock(state, flags);
A
Alan Cox 已提交
623
	ret = uart_circ_chars_pending(&state->xmit);
624
	uart_port_unlock(port, flags);
A
Alan Cox 已提交
625
	return ret;
L
Linus Torvalds 已提交
626 627 628 629 630
}

static void uart_flush_buffer(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
631
	struct uart_port *port;
L
Linus Torvalds 已提交
632 633
	unsigned long flags;

634 635 636 637
	/*
	 * This means you called this function _after_ the port was
	 * closed.  No cookie for you.
	 */
638
	if (!state) {
639 640 641 642
		WARN_ON(1);
		return;
	}

J
Jiri Slaby 已提交
643
	pr_debug("uart_flush_buffer(%d) called\n", tty->index);
L
Linus Torvalds 已提交
644

645 646 647
	port = uart_port_lock(state, flags);
	if (!port)
		return;
A
Alan Cox 已提交
648
	uart_circ_clear(&state->xmit);
649 650
	if (port->ops->flush_buffer)
		port->ops->flush_buffer(port);
651
	uart_port_unlock(port, flags);
652
	tty_port_tty_wakeup(&state->port);
L
Linus Torvalds 已提交
653 654 655 656 657 658 659 660 661
}

/*
 * This function is used to send a high-priority XON/XOFF character to
 * the device
 */
static void uart_send_xchar(struct tty_struct *tty, char ch)
{
	struct uart_state *state = tty->driver_data;
662
	struct uart_port *port;
L
Linus Torvalds 已提交
663 664
	unsigned long flags;

665 666 667 668
	port = uart_port_ref(state);
	if (!port)
		return;

L
Linus Torvalds 已提交
669 670 671
	if (port->ops->send_xchar)
		port->ops->send_xchar(port, ch);
	else {
P
Peter Hurley 已提交
672
		spin_lock_irqsave(&port->lock, flags);
L
Linus Torvalds 已提交
673
		port->x_char = ch;
P
Peter Hurley 已提交
674
		if (ch)
675
			port->ops->start_tx(port);
P
Peter Hurley 已提交
676
		spin_unlock_irqrestore(&port->lock, flags);
L
Linus Torvalds 已提交
677
	}
678
	uart_port_deref(port);
L
Linus Torvalds 已提交
679 680 681 682 683
}

static void uart_throttle(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
684
	upstat_t mask = UPSTAT_SYNC_FIFO;
685
	struct uart_port *port;
L
Linus Torvalds 已提交
686

687 688 689 690
	port = uart_port_ref(state);
	if (!port)
		return;

L
Linus Torvalds 已提交
691
	if (I_IXOFF(tty))
692
		mask |= UPSTAT_AUTOXOFF;
P
Peter Hurley 已提交
693
	if (C_CRTSCTS(tty))
694
		mask |= UPSTAT_AUTORTS;
695

696
	if (port->status & mask) {
697
		port->ops->throttle(port);
698
		mask &= ~port->status;
699 700
	}

701
	if (mask & UPSTAT_AUTORTS)
702
		uart_clear_mctrl(port, TIOCM_RTS);
703 704 705

	if (mask & UPSTAT_AUTOXOFF)
		uart_send_xchar(tty, STOP_CHAR(tty));
706 707

	uart_port_deref(port);
L
Linus Torvalds 已提交
708 709 710 711 712
}

static void uart_unthrottle(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
713
	upstat_t mask = UPSTAT_SYNC_FIFO;
714
	struct uart_port *port;
L
Linus Torvalds 已提交
715

716 717 718 719
	port = uart_port_ref(state);
	if (!port)
		return;

720
	if (I_IXOFF(tty))
721
		mask |= UPSTAT_AUTOXOFF;
P
Peter Hurley 已提交
722
	if (C_CRTSCTS(tty))
723
		mask |= UPSTAT_AUTORTS;
724

725
	if (port->status & mask) {
726
		port->ops->unthrottle(port);
727
		mask &= ~port->status;
728
	}
L
Linus Torvalds 已提交
729

730
	if (mask & UPSTAT_AUTORTS)
L
Linus Torvalds 已提交
731
		uart_set_mctrl(port, TIOCM_RTS);
732 733 734

	if (mask & UPSTAT_AUTOXOFF)
		uart_send_xchar(tty, START_CHAR(tty));
735 736

	uart_port_deref(port);
L
Linus Torvalds 已提交
737 738
}

739
static int uart_get_info(struct tty_port *port, struct serial_struct *retinfo)
L
Linus Torvalds 已提交
740
{
A
Alan Cox 已提交
741
	struct uart_state *state = container_of(port, struct uart_state, port);
742 743
	struct uart_port *uport;
	int ret = -ENODEV;
A
Alan Cox 已提交
744

F
Fengguang Wu 已提交
745
	memset(retinfo, 0, sizeof(*retinfo));
A
Alan Cox 已提交
746

747 748 749 750 751
	/*
	 * Ensure the state we copy is consistent and no hardware changes
	 * occur as we go
	 */
	mutex_lock(&port->mutex);
752 753 754 755
	uport = uart_port_check(state);
	if (!uport)
		goto out;

756 757 758
	retinfo->type	    = uport->type;
	retinfo->line	    = uport->line;
	retinfo->port	    = uport->iobase;
L
Linus Torvalds 已提交
759
	if (HIGH_BITS_OFFSET)
760 761
		retinfo->port_high = (long) uport->iobase >> HIGH_BITS_OFFSET;
	retinfo->irq		    = uport->irq;
762
	retinfo->flags	    = (__force int)uport->flags;
763 764 765 766
	retinfo->xmit_fifo_size  = uport->fifosize;
	retinfo->baud_base	    = uport->uartclk / 16;
	retinfo->close_delay	    = jiffies_to_msecs(port->close_delay) / 10;
	retinfo->closing_wait    = port->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
L
Linus Torvalds 已提交
767
				ASYNC_CLOSING_WAIT_NONE :
768
				jiffies_to_msecs(port->closing_wait) / 10;
769 770 771 772 773
	retinfo->custom_divisor  = uport->custom_divisor;
	retinfo->hub6	    = uport->hub6;
	retinfo->io_type         = uport->iotype;
	retinfo->iomem_reg_shift = uport->regshift;
	retinfo->iomem_base      = (void *)(unsigned long)uport->mapbase;
774 775 776

	ret = 0;
out:
777
	mutex_unlock(&port->mutex);
778
	return ret;
A
Alan Cox 已提交
779 780
}

A
Al Viro 已提交
781 782
static int uart_get_info_user(struct tty_struct *tty,
			 struct serial_struct *ss)
A
Alan Cox 已提交
783
{
A
Al Viro 已提交
784 785
	struct uart_state *state = tty->driver_data;
	struct tty_port *port = &state->port;
A
Alan Cox 已提交
786

A
Al Viro 已提交
787
	return uart_get_info(port, ss) < 0 ? -EIO : 0;
L
Linus Torvalds 已提交
788 789
}

790 791 792
static int uart_set_info(struct tty_struct *tty, struct tty_port *port,
			 struct uart_state *state,
			 struct serial_struct *new_info)
L
Linus Torvalds 已提交
793
{
794
	struct uart_port *uport = uart_port_check(state);
L
Linus Torvalds 已提交
795
	unsigned long new_port;
796
	unsigned int change_irq, change_port, closing_wait;
L
Linus Torvalds 已提交
797
	unsigned int old_custom_divisor, close_delay;
798
	upf_t old_flags, new_flags;
L
Linus Torvalds 已提交
799 800
	int retval = 0;

801 802 803
	if (!uport)
		return -EIO;

804
	new_port = new_info->port;
L
Linus Torvalds 已提交
805
	if (HIGH_BITS_OFFSET)
806
		new_port += (unsigned long) new_info->port_high << HIGH_BITS_OFFSET;
L
Linus Torvalds 已提交
807

808 809 810
	new_info->irq = irq_canonicalize(new_info->irq);
	close_delay = msecs_to_jiffies(new_info->close_delay * 10);
	closing_wait = new_info->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
811
			ASYNC_CLOSING_WAIT_NONE :
812
			msecs_to_jiffies(new_info->closing_wait * 10);
L
Linus Torvalds 已提交
813 814


815
	change_irq  = !(uport->flags & UPF_FIXED_PORT)
816
		&& new_info->irq != uport->irq;
L
Linus Torvalds 已提交
817 818 819 820 821 822

	/*
	 * Since changing the 'type' of the port changes its resource
	 * allocations, we should treat type changes the same as
	 * IO port changes.
	 */
823 824
	change_port = !(uport->flags & UPF_FIXED_PORT)
		&& (new_port != uport->iobase ||
825 826 827 828 829
		    (unsigned long)new_info->iomem_base != uport->mapbase ||
		    new_info->hub6 != uport->hub6 ||
		    new_info->io_type != uport->iotype ||
		    new_info->iomem_reg_shift != uport->regshift ||
		    new_info->type != uport->type);
830 831

	old_flags = uport->flags;
832
	new_flags = (__force upf_t)new_info->flags;
833
	old_custom_divisor = uport->custom_divisor;
L
Linus Torvalds 已提交
834 835 836 837

	if (!capable(CAP_SYS_ADMIN)) {
		retval = -EPERM;
		if (change_irq || change_port ||
838
		    (new_info->baud_base != uport->uartclk / 16) ||
839 840
		    (close_delay != port->close_delay) ||
		    (closing_wait != port->closing_wait) ||
841 842
		    (new_info->xmit_fifo_size &&
		     new_info->xmit_fifo_size != uport->fifosize) ||
843
		    (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))
L
Linus Torvalds 已提交
844
			goto exit;
845
		uport->flags = ((uport->flags & ~UPF_USR_MASK) |
846
			       (new_flags & UPF_USR_MASK));
847
		uport->custom_divisor = new_info->custom_divisor;
L
Linus Torvalds 已提交
848 849 850 851 852 853
		goto check_and_exit;
	}

	/*
	 * Ask the low level driver to verify the settings.
	 */
854
	if (uport->ops->verify_port)
855
		retval = uport->ops->verify_port(uport, new_info);
L
Linus Torvalds 已提交
856

857 858
	if ((new_info->irq >= nr_irqs) || (new_info->irq < 0) ||
	    (new_info->baud_base < 9600))
L
Linus Torvalds 已提交
859 860 861 862 863 864 865 866 867 868 869
		retval = -EINVAL;

	if (retval)
		goto exit;

	if (change_port || change_irq) {
		retval = -EBUSY;

		/*
		 * Make sure that we are the sole user of this port.
		 */
A
Alan Cox 已提交
870
		if (tty_port_users(port) > 1)
L
Linus Torvalds 已提交
871 872 873 874 875 876
			goto exit;

		/*
		 * We need to shutdown the serial port at the old
		 * port/type/irq combination.
		 */
877
		uart_shutdown(tty, state);
L
Linus Torvalds 已提交
878 879 880 881 882 883
	}

	if (change_port) {
		unsigned long old_iobase, old_mapbase;
		unsigned int old_type, old_iotype, old_hub6, old_shift;

884 885 886 887 888 889
		old_iobase = uport->iobase;
		old_mapbase = uport->mapbase;
		old_type = uport->type;
		old_hub6 = uport->hub6;
		old_iotype = uport->iotype;
		old_shift = uport->regshift;
L
Linus Torvalds 已提交
890 891 892 893

		/*
		 * Free and release old regions
		 */
894
		if (old_type != PORT_UNKNOWN && uport->ops->release_port)
895
			uport->ops->release_port(uport);
L
Linus Torvalds 已提交
896

897
		uport->iobase = new_port;
898 899 900 901 902
		uport->type = new_info->type;
		uport->hub6 = new_info->hub6;
		uport->iotype = new_info->io_type;
		uport->regshift = new_info->iomem_reg_shift;
		uport->mapbase = (unsigned long)new_info->iomem_base;
L
Linus Torvalds 已提交
903 904 905 906

		/*
		 * Claim and map the new regions
		 */
907
		if (uport->type != PORT_UNKNOWN && uport->ops->request_port) {
908
			retval = uport->ops->request_port(uport);
L
Linus Torvalds 已提交
909 910 911 912 913 914 915 916 917
		} else {
			/* Always success - Jean II */
			retval = 0;
		}

		/*
		 * If we fail to request resources for the
		 * new port, try to restore the old settings.
		 */
918
		if (retval) {
919 920 921 922 923 924
			uport->iobase = old_iobase;
			uport->type = old_type;
			uport->hub6 = old_hub6;
			uport->iotype = old_iotype;
			uport->regshift = old_shift;
			uport->mapbase = old_mapbase;
L
Linus Torvalds 已提交
925

926 927 928 929 930 931 932 933 934 935 936 937 938 939 940
			if (old_type != PORT_UNKNOWN) {
				retval = uport->ops->request_port(uport);
				/*
				 * If we failed to restore the old settings,
				 * we fail like this.
				 */
				if (retval)
					uport->type = PORT_UNKNOWN;

				/*
				 * We failed anyway.
				 */
				retval = -EBUSY;
			}

941 942
			/* Added to return the correct error -Ram Gupta */
			goto exit;
L
Linus Torvalds 已提交
943 944 945
		}
	}

946
	if (change_irq)
947
		uport->irq      = new_info->irq;
948
	if (!(uport->flags & UPF_FIXED_PORT))
949
		uport->uartclk  = new_info->baud_base * 16;
950
	uport->flags            = (uport->flags & ~UPF_CHANGE_MASK) |
951
				 (new_flags & UPF_CHANGE_MASK);
952
	uport->custom_divisor   = new_info->custom_divisor;
953 954
	port->close_delay     = close_delay;
	port->closing_wait    = closing_wait;
955 956
	if (new_info->xmit_fifo_size)
		uport->fifosize = new_info->xmit_fifo_size;
J
Jiri Slaby 已提交
957
	port->low_latency = (uport->flags & UPF_LOW_LATENCY) ? 1 : 0;
L
Linus Torvalds 已提交
958 959 960

 check_and_exit:
	retval = 0;
961
	if (uport->type == PORT_UNKNOWN)
L
Linus Torvalds 已提交
962
		goto exit;
963
	if (tty_port_initialized(port)) {
964 965
		if (((old_flags ^ uport->flags) & UPF_SPD_MASK) ||
		    old_custom_divisor != uport->custom_divisor) {
L
Linus Torvalds 已提交
966 967
			/*
			 * If they're setting up a custom divisor or speed,
968
			 * instead of clearing it, then bitch about it.
L
Linus Torvalds 已提交
969
			 */
970
			if (uport->flags & UPF_SPD_MASK) {
971
				dev_notice_ratelimited(uport->dev,
972 973
				       "%s sets custom speed on %s. This is deprecated.\n",
				      current->comm,
974
				      tty_name(port->tty));
L
Linus Torvalds 已提交
975
			}
976
			uart_change_speed(tty, state, NULL);
L
Linus Torvalds 已提交
977
		}
978
	} else {
979
		retval = uart_startup(tty, state, 1);
980 981
		if (retval == 0)
			tty_port_set_initialized(port, true);
982 983 984
		if (retval > 0)
			retval = 0;
	}
L
Linus Torvalds 已提交
985
 exit:
986 987 988
	return retval;
}

A
Al Viro 已提交
989
static int uart_set_info_user(struct tty_struct *tty, struct serial_struct *ss)
990
{
A
Al Viro 已提交
991
	struct uart_state *state = tty->driver_data;
992 993 994
	struct tty_port *port = &state->port;
	int retval;

A
Al Viro 已提交
995
	down_write(&tty->termios_rwsem);
996 997 998 999 1000 1001 1002 1003
	/*
	 * This semaphore protects port->count.  It is also
	 * very useful to prevent opens.  Also, take the
	 * port configuration semaphore to make sure that a
	 * module insertion/removal doesn't change anything
	 * under us.
	 */
	mutex_lock(&port->mutex);
A
Al Viro 已提交
1004
	retval = uart_set_info(tty, port, state, ss);
1005
	mutex_unlock(&port->mutex);
A
Al Viro 已提交
1006
	up_write(&tty->termios_rwsem);
L
Linus Torvalds 已提交
1007 1008 1009
	return retval;
}

1010 1011 1012 1013 1014
/**
 *	uart_get_lsr_info	-	get line status register info
 *	@tty: tty associated with the UART
 *	@state: UART being queried
 *	@value: returned modem value
L
Linus Torvalds 已提交
1015
 */
1016 1017
static int uart_get_lsr_info(struct tty_struct *tty,
			struct uart_state *state, unsigned int __user *value)
L
Linus Torvalds 已提交
1018
{
1019
	struct uart_port *uport = uart_port_check(state);
L
Linus Torvalds 已提交
1020 1021
	unsigned int result;

1022
	result = uport->ops->tx_empty(uport);
L
Linus Torvalds 已提交
1023 1024 1025 1026 1027 1028 1029

	/*
	 * If we're about to load something into the transmit
	 * register, we'll pretend the transmitter isn't empty to
	 * avoid a race condition (depending on when the transmit
	 * interrupt happens).
	 */
1030
	if (uport->x_char ||
A
Alan Cox 已提交
1031
	    ((uart_circ_chars_pending(&state->xmit) > 0) &&
1032
	     !uart_tx_stopped(uport)))
L
Linus Torvalds 已提交
1033
		result &= ~TIOCSER_TEMT;
1034

L
Linus Torvalds 已提交
1035 1036 1037
	return put_user(result, value);
}

1038
static int uart_tiocmget(struct tty_struct *tty)
L
Linus Torvalds 已提交
1039 1040
{
	struct uart_state *state = tty->driver_data;
1041
	struct tty_port *port = &state->port;
1042
	struct uart_port *uport;
L
Linus Torvalds 已提交
1043 1044
	int result = -EIO;

1045
	mutex_lock(&port->mutex);
1046 1047 1048 1049
	uport = uart_port_check(state);
	if (!uport)
		goto out;

1050
	if (!tty_io_error(tty)) {
1051 1052 1053 1054
		result = uport->mctrl;
		spin_lock_irq(&uport->lock);
		result |= uport->ops->get_mctrl(uport);
		spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
1055
	}
1056
out:
1057
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
1058 1059 1060 1061
	return result;
}

static int
1062
uart_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
L
Linus Torvalds 已提交
1063 1064
{
	struct uart_state *state = tty->driver_data;
1065
	struct tty_port *port = &state->port;
1066
	struct uart_port *uport;
L
Linus Torvalds 已提交
1067 1068
	int ret = -EIO;

1069
	mutex_lock(&port->mutex);
1070 1071 1072 1073
	uport = uart_port_check(state);
	if (!uport)
		goto out;

1074
	if (!tty_io_error(tty)) {
1075
		uart_update_mctrl(uport, set, clear);
L
Linus Torvalds 已提交
1076 1077
		ret = 0;
	}
1078
out:
1079
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
1080 1081 1082
	return ret;
}

A
Alan Cox 已提交
1083
static int uart_break_ctl(struct tty_struct *tty, int break_state)
L
Linus Torvalds 已提交
1084 1085
{
	struct uart_state *state = tty->driver_data;
1086
	struct tty_port *port = &state->port;
1087 1088
	struct uart_port *uport;
	int ret = -EIO;
L
Linus Torvalds 已提交
1089

1090
	mutex_lock(&port->mutex);
1091 1092 1093
	uport = uart_port_check(state);
	if (!uport)
		goto out;
L
Linus Torvalds 已提交
1094

1095 1096
	if (uport->type != PORT_UNKNOWN)
		uport->ops->break_ctl(uport, break_state);
1097 1098
	ret = 0;
out:
1099
	mutex_unlock(&port->mutex);
1100
	return ret;
L
Linus Torvalds 已提交
1101 1102
}

1103
static int uart_do_autoconfig(struct tty_struct *tty,struct uart_state *state)
L
Linus Torvalds 已提交
1104
{
1105
	struct tty_port *port = &state->port;
1106
	struct uart_port *uport;
L
Linus Torvalds 已提交
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
	int flags, ret;

	if (!capable(CAP_SYS_ADMIN))
		return -EPERM;

	/*
	 * Take the per-port semaphore.  This prevents count from
	 * changing, and hence any extra opens of the port while
	 * we're auto-configuring.
	 */
1117
	if (mutex_lock_interruptible(&port->mutex))
L
Linus Torvalds 已提交
1118 1119
		return -ERESTARTSYS;

1120 1121 1122 1123 1124 1125
	uport = uart_port_check(state);
	if (!uport) {
		ret = -EIO;
		goto out;
	}

L
Linus Torvalds 已提交
1126
	ret = -EBUSY;
A
Alan Cox 已提交
1127
	if (tty_port_users(port) == 1) {
1128
		uart_shutdown(tty, state);
L
Linus Torvalds 已提交
1129 1130 1131 1132 1133

		/*
		 * If we already have a port type configured,
		 * we must release its resources.
		 */
1134
		if (uport->type != PORT_UNKNOWN && uport->ops->release_port)
1135
			uport->ops->release_port(uport);
L
Linus Torvalds 已提交
1136 1137

		flags = UART_CONFIG_TYPE;
1138
		if (uport->flags & UPF_AUTO_IRQ)
L
Linus Torvalds 已提交
1139 1140 1141 1142 1143 1144
			flags |= UART_CONFIG_IRQ;

		/*
		 * This will claim the ports resources if
		 * a port is found.
		 */
1145
		uport->ops->config_port(uport, flags);
L
Linus Torvalds 已提交
1146

1147
		ret = uart_startup(tty, state, 1);
1148 1149
		if (ret == 0)
			tty_port_set_initialized(port, true);
1150 1151
		if (ret > 0)
			ret = 0;
L
Linus Torvalds 已提交
1152
	}
1153
out:
1154
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
1155 1156 1157
	return ret;
}

1158 1159 1160 1161 1162 1163 1164 1165 1166
static void uart_enable_ms(struct uart_port *uport)
{
	/*
	 * Force modem status interrupts on
	 */
	if (uport->ops->enable_ms)
		uport->ops->enable_ms(uport);
}

L
Linus Torvalds 已提交
1167 1168 1169 1170 1171
/*
 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
 * - mask passed in arg for lines of interest
 *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
 * Caller should use TIOCGICOUNT to see which one it was
1172 1173 1174
 *
 * FIXME: This wants extracting into a common all driver implementation
 * of TIOCMWAIT using tty_port.
L
Linus Torvalds 已提交
1175
 */
1176
static int uart_wait_modem_status(struct uart_state *state, unsigned long arg)
L
Linus Torvalds 已提交
1177
{
1178
	struct uart_port *uport;
1179
	struct tty_port *port = &state->port;
L
Linus Torvalds 已提交
1180 1181 1182 1183 1184 1185 1186
	DECLARE_WAITQUEUE(wait, current);
	struct uart_icount cprev, cnow;
	int ret;

	/*
	 * note the counters on entry
	 */
1187 1188 1189
	uport = uart_port_ref(state);
	if (!uport)
		return -EIO;
1190 1191
	spin_lock_irq(&uport->lock);
	memcpy(&cprev, &uport->icount, sizeof(struct uart_icount));
1192
	uart_enable_ms(uport);
1193
	spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
1194

1195
	add_wait_queue(&port->delta_msr_wait, &wait);
L
Linus Torvalds 已提交
1196
	for (;;) {
1197 1198 1199
		spin_lock_irq(&uport->lock);
		memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
		spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
1200 1201 1202 1203 1204 1205 1206

		set_current_state(TASK_INTERRUPTIBLE);

		if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
		    ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
		    ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
		    ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
1207 1208
			ret = 0;
			break;
L
Linus Torvalds 已提交
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220
		}

		schedule();

		/* see if a signal did it */
		if (signal_pending(current)) {
			ret = -ERESTARTSYS;
			break;
		}

		cprev = cnow;
	}
1221
	__set_current_state(TASK_RUNNING);
1222
	remove_wait_queue(&port->delta_msr_wait, &wait);
1223
	uart_port_deref(uport);
L
Linus Torvalds 已提交
1224 1225 1226 1227 1228 1229 1230 1231 1232 1233

	return ret;
}

/*
 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
 * Return: write counters to the user passed counter struct
 * NB: both 1->0 and 0->1 transitions are counted except for
 *     RI where only 0->1 is counted.
 */
A
Alan Cox 已提交
1234 1235
static int uart_get_icount(struct tty_struct *tty,
			  struct serial_icounter_struct *icount)
L
Linus Torvalds 已提交
1236
{
A
Alan Cox 已提交
1237
	struct uart_state *state = tty->driver_data;
L
Linus Torvalds 已提交
1238
	struct uart_icount cnow;
1239
	struct uart_port *uport;
L
Linus Torvalds 已提交
1240

1241 1242 1243
	uport = uart_port_ref(state);
	if (!uport)
		return -EIO;
1244 1245 1246
	spin_lock_irq(&uport->lock);
	memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
	spin_unlock_irq(&uport->lock);
1247
	uart_port_deref(uport);
L
Linus Torvalds 已提交
1248

A
Alan Cox 已提交
1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261
	icount->cts         = cnow.cts;
	icount->dsr         = cnow.dsr;
	icount->rng         = cnow.rng;
	icount->dcd         = cnow.dcd;
	icount->rx          = cnow.rx;
	icount->tx          = cnow.tx;
	icount->frame       = cnow.frame;
	icount->overrun     = cnow.overrun;
	icount->parity      = cnow.parity;
	icount->brk         = cnow.brk;
	icount->buf_overrun = cnow.buf_overrun;

	return 0;
L
Linus Torvalds 已提交
1262 1263
}

1264 1265 1266
static int uart_get_rs485_config(struct uart_port *port,
			 struct serial_rs485 __user *rs485)
{
1267 1268 1269 1270 1271 1272 1273 1274
	unsigned long flags;
	struct serial_rs485 aux;

	spin_lock_irqsave(&port->lock, flags);
	aux = port->rs485;
	spin_unlock_irqrestore(&port->lock, flags);

	if (copy_to_user(rs485, &aux, sizeof(aux)))
1275
		return -EFAULT;
1276

1277 1278 1279 1280 1281 1282 1283 1284
	return 0;
}

static int uart_set_rs485_config(struct uart_port *port,
			 struct serial_rs485 __user *rs485_user)
{
	struct serial_rs485 rs485;
	int ret;
1285
	unsigned long flags;
1286 1287 1288 1289 1290 1291 1292

	if (!port->rs485_config)
		return -ENOIOCTLCMD;

	if (copy_from_user(&rs485, rs485_user, sizeof(*rs485_user)))
		return -EFAULT;

1293
	spin_lock_irqsave(&port->lock, flags);
1294
	ret = port->rs485_config(port, &rs485);
1295
	spin_unlock_irqrestore(&port->lock, flags);
1296 1297 1298 1299 1300 1301 1302 1303 1304
	if (ret)
		return ret;

	if (copy_to_user(rs485_user, &port->rs485, sizeof(port->rs485)))
		return -EFAULT;

	return 0;
}

L
Linus Torvalds 已提交
1305
/*
1306
 * Called via sys_ioctl.  We can use spin_lock_irq() here.
L
Linus Torvalds 已提交
1307 1308
 */
static int
1309
uart_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
1310 1311
{
	struct uart_state *state = tty->driver_data;
1312
	struct tty_port *port = &state->port;
1313
	struct uart_port *uport;
L
Linus Torvalds 已提交
1314 1315 1316 1317 1318 1319 1320 1321 1322
	void __user *uarg = (void __user *)arg;
	int ret = -ENOIOCTLCMD;


	/*
	 * These ioctls don't rely on the hardware to be present.
	 */
	switch (cmd) {
	case TIOCSERCONFIG:
1323
		down_write(&tty->termios_rwsem);
1324
		ret = uart_do_autoconfig(tty, state);
1325
		up_write(&tty->termios_rwsem);
L
Linus Torvalds 已提交
1326 1327 1328 1329 1330 1331
		break;
	}

	if (ret != -ENOIOCTLCMD)
		goto out;

1332
	if (tty_io_error(tty)) {
L
Linus Torvalds 已提交
1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348
		ret = -EIO;
		goto out;
	}

	/*
	 * The following should only be used when hardware is present.
	 */
	switch (cmd) {
	case TIOCMIWAIT:
		ret = uart_wait_modem_status(state, arg);
		break;
	}

	if (ret != -ENOIOCTLCMD)
		goto out;

1349
	mutex_lock(&port->mutex);
1350
	uport = uart_port_check(state);
L
Linus Torvalds 已提交
1351

1352
	if (!uport || tty_io_error(tty)) {
L
Linus Torvalds 已提交
1353 1354 1355 1356 1357 1358 1359 1360
		ret = -EIO;
		goto out_up;
	}

	/*
	 * All these rely on hardware being present and need to be
	 * protected against the tty being hung up.
	 */
1361

L
Linus Torvalds 已提交
1362
	switch (cmd) {
1363 1364 1365 1366
	case TIOCSERGETLSR: /* Get line status register */
		ret = uart_get_lsr_info(tty, state, uarg);
		break;

1367
	case TIOCGRS485:
1368
		ret = uart_get_rs485_config(uport, uarg);
1369 1370 1371
		break;

	case TIOCSRS485:
1372
		ret = uart_set_rs485_config(uport, uarg);
1373
		break;
1374
	default:
1375 1376
		if (uport->ops->ioctl)
			ret = uport->ops->ioctl(uport, cmd, arg);
L
Linus Torvalds 已提交
1377 1378
		break;
	}
A
Alan Cox 已提交
1379
out_up:
1380
	mutex_unlock(&port->mutex);
A
Alan Cox 已提交
1381
out:
L
Linus Torvalds 已提交
1382 1383 1384
	return ret;
}

1385
static void uart_set_ldisc(struct tty_struct *tty)
1386 1387
{
	struct uart_state *state = tty->driver_data;
1388
	struct uart_port *uport;
1389

1390 1391 1392
	mutex_lock(&state->port.mutex);
	uport = uart_port_check(state);
	if (uport && uport->ops->set_ldisc)
1393
		uport->ops->set_ldisc(uport, &tty->termios);
1394
	mutex_unlock(&state->port.mutex);
1395 1396
}

1397 1398
static void uart_set_termios(struct tty_struct *tty,
						struct ktermios *old_termios)
L
Linus Torvalds 已提交
1399 1400
{
	struct uart_state *state = tty->driver_data;
1401
	struct uart_port *uport;
1402
	unsigned int cflag = tty->termios.c_cflag;
1403 1404
	unsigned int iflag_mask = IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK;
	bool sw_changed = false;
L
Linus Torvalds 已提交
1405

1406 1407 1408 1409 1410
	mutex_lock(&state->port.mutex);
	uport = uart_port_check(state);
	if (!uport)
		goto out;

1411 1412 1413 1414 1415 1416 1417 1418 1419 1420
	/*
	 * Drivers doing software flow control also need to know
	 * about changes to these input settings.
	 */
	if (uport->flags & UPF_SOFT_FLOW) {
		iflag_mask |= IXANY|IXON|IXOFF;
		sw_changed =
		   tty->termios.c_cc[VSTART] != old_termios->c_cc[VSTART] ||
		   tty->termios.c_cc[VSTOP] != old_termios->c_cc[VSTOP];
	}
L
Linus Torvalds 已提交
1421 1422 1423

	/*
	 * These are the bits that are used to setup various
1424 1425 1426
	 * flags in the low level driver. We can ignore the Bfoo
	 * bits in c_cflag; c_[io]speed will always be set
	 * appropriately by set_termios() in tty_ioctl.c
L
Linus Torvalds 已提交
1427 1428
	 */
	if ((cflag ^ old_termios->c_cflag) == 0 &&
1429 1430
	    tty->termios.c_ospeed == old_termios->c_ospeed &&
	    tty->termios.c_ispeed == old_termios->c_ispeed &&
1431 1432
	    ((tty->termios.c_iflag ^ old_termios->c_iflag) & iflag_mask) == 0 &&
	    !sw_changed) {
1433
		goto out;
1434
	}
L
Linus Torvalds 已提交
1435

1436
	uart_change_speed(tty, state, old_termios);
1437 1438
	/* reload cflag from termios; port driver may have overriden flags */
	cflag = tty->termios.c_cflag;
L
Linus Torvalds 已提交
1439 1440 1441

	/* Handle transition to B0 status */
	if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
1442
		uart_clear_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
L
Linus Torvalds 已提交
1443
	/* Handle transition away from B0 status */
1444
	else if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
L
Linus Torvalds 已提交
1445
		unsigned int mask = TIOCM_DTR;
1446
		if (!(cflag & CRTSCTS) || !tty_throttled(tty))
L
Linus Torvalds 已提交
1447
			mask |= TIOCM_RTS;
1448
		uart_set_mctrl(uport, mask);
L
Linus Torvalds 已提交
1449
	}
1450 1451
out:
	mutex_unlock(&state->port.mutex);
L
Linus Torvalds 已提交
1452 1453 1454
}

/*
1455 1456 1457
 * Calls to uart_close() are serialised via the tty_lock in
 *   drivers/tty/tty_io.c:tty_release()
 *   drivers/tty/tty_io.c:do_tty_hangup()
L
Linus Torvalds 已提交
1458 1459 1460 1461
 */
static void uart_close(struct tty_struct *tty, struct file *filp)
{
	struct uart_state *state = tty->driver_data;
1462

1463 1464
	if (!state) {
		struct uart_driver *drv = tty->driver->driver_state;
1465
		struct tty_port *port;
1466 1467 1468 1469 1470 1471

		state = drv->state + tty->index;
		port = &state->port;
		spin_lock_irq(&port->lock);
		--port->count;
		spin_unlock_irq(&port->lock);
1472
		return;
1473
	}
1474

1475
	pr_debug("uart_close(%d) called\n", tty->index);
L
Linus Torvalds 已提交
1476

1477 1478
	tty_port_close(tty->port, tty, filp);
}
L
Linus Torvalds 已提交
1479

1480 1481 1482 1483
static void uart_tty_port_shutdown(struct tty_port *port)
{
	struct uart_state *state = container_of(port, struct uart_state, port);
	struct uart_port *uport = uart_port_check(state);
1484

L
Linus Torvalds 已提交
1485 1486 1487 1488
	/*
	 * At this point, we stop accepting input.  To do this, we
	 * disable the receive line status interrupts.
	 */
1489 1490
	if (WARN(!uport, "detached port still initialized!\n"))
		return;
L
Linus Torvalds 已提交
1491

1492
	spin_lock_irq(&uport->lock);
1493 1494
	uport->ops->stop_rx(uport);
	spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
1495

1496
	uart_port_shutdown(port);
L
Linus Torvalds 已提交
1497 1498

	/*
1499 1500 1501
	 * It's possible for shutdown to be called after suspend if we get
	 * a DCD drop (hangup) at just the right time.  Clear suspended bit so
	 * we don't try to resume a port that has been shutdown.
L
Linus Torvalds 已提交
1502
	 */
1503
	tty_port_set_suspended(port, 0);
L
Linus Torvalds 已提交
1504

1505
	uart_change_pm(state, UART_PM_STATE_OFF);
1506

L
Linus Torvalds 已提交
1507 1508
}

1509
static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
L
Linus Torvalds 已提交
1510
{
1511
	struct uart_state *state = tty->driver_data;
1512
	struct uart_port *port;
L
Linus Torvalds 已提交
1513 1514
	unsigned long char_time, expire;

1515
	port = uart_port_ref(state);
1516 1517 1518 1519
	if (!port)
		return;

	if (port->type == PORT_UNKNOWN || port->fifosize == 0) {
1520
		uart_port_deref(port);
L
Linus Torvalds 已提交
1521
		return;
1522
	}
L
Linus Torvalds 已提交
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552

	/*
	 * Set the check interval to be 1/5 of the estimated time to
	 * send a single character, and make it at least 1.  The check
	 * interval should also be less than the timeout.
	 *
	 * Note: we have to use pretty tight timings here to satisfy
	 * the NIST-PCTS.
	 */
	char_time = (port->timeout - HZ/50) / port->fifosize;
	char_time = char_time / 5;
	if (char_time == 0)
		char_time = 1;
	if (timeout && timeout < char_time)
		char_time = timeout;

	/*
	 * If the transmitter hasn't cleared in twice the approximate
	 * amount of time to send the entire FIFO, it probably won't
	 * ever clear.  This assumes the UART isn't doing flow
	 * control, which is currently the case.  Hence, if it ever
	 * takes longer than port->timeout, this is probably due to a
	 * UART bug of some kind.  So, we clamp the timeout parameter at
	 * 2*port->timeout.
	 */
	if (timeout == 0 || timeout > 2 * port->timeout)
		timeout = 2 * port->timeout;

	expire = jiffies + timeout;

J
Jiri Slaby 已提交
1553
	pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n",
1554
		port->line, jiffies, expire);
L
Linus Torvalds 已提交
1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567

	/*
	 * Check whether the transmitter is empty every 'char_time'.
	 * 'timeout' / 'expire' give us the maximum amount of time
	 * we wait.
	 */
	while (!port->ops->tx_empty(port)) {
		msleep_interruptible(jiffies_to_msecs(char_time));
		if (signal_pending(current))
			break;
		if (time_after(jiffies, expire))
			break;
	}
1568
	uart_port_deref(port);
1569 1570
}

L
Linus Torvalds 已提交
1571
/*
1572 1573 1574
 * Calls to uart_hangup() are serialised by the tty_lock in
 *   drivers/tty/tty_io.c:do_tty_hangup()
 * This runs from a workqueue and can sleep for a _short_ time only.
L
Linus Torvalds 已提交
1575 1576 1577 1578
 */
static void uart_hangup(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
1579
	struct tty_port *port = &state->port;
1580
	struct uart_port *uport;
1581
	unsigned long flags;
L
Linus Torvalds 已提交
1582

1583
	pr_debug("uart_hangup(%d)\n", tty->index);
L
Linus Torvalds 已提交
1584

1585
	mutex_lock(&port->mutex);
1586 1587 1588
	uport = uart_port_check(state);
	WARN(!uport, "hangup of detached port!\n");

1589
	if (tty_port_active(port)) {
L
Linus Torvalds 已提交
1590
		uart_flush_buffer(tty);
1591
		uart_shutdown(tty, state);
1592
		spin_lock_irqsave(&port->lock, flags);
1593
		port->count = 0;
1594
		spin_unlock_irqrestore(&port->lock, flags);
1595
		tty_port_set_active(port, 0);
A
Alan Cox 已提交
1596
		tty_port_tty_set(port, NULL);
1597
		if (uport && !uart_console(uport))
1598
			uart_change_pm(state, UART_PM_STATE_OFF);
1599
		wake_up_interruptible(&port->open_wait);
1600
		wake_up_interruptible(&port->delta_msr_wait);
L
Linus Torvalds 已提交
1601
	}
1602
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
1603 1604
}

1605
/* uport == NULL if uart_port has already been removed */
1606 1607
static void uart_port_shutdown(struct tty_port *port)
{
J
Jiri Slaby 已提交
1608
	struct uart_state *state = container_of(port, struct uart_state, port);
1609
	struct uart_port *uport = uart_port_check(state);
J
Jiri Slaby 已提交
1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622

	/*
	 * clear delta_msr_wait queue to avoid mem leaks: we may free
	 * the irq here so the queue might never be woken up.  Note
	 * that we won't end up waiting on delta_msr_wait again since
	 * any outstanding file descriptors should be pointing at
	 * hung_up_tty_fops now.
	 */
	wake_up_interruptible(&port->delta_msr_wait);

	/*
	 * Free the IRQ and disable the port.
	 */
1623 1624
	if (uport)
		uport->ops->shutdown(uport);
J
Jiri Slaby 已提交
1625 1626 1627 1628

	/*
	 * Ensure that the IRQ handler isn't running on another CPU.
	 */
1629 1630
	if (uport)
		synchronize_irq(uport->irq);
1631 1632
}

A
Alan Cox 已提交
1633 1634 1635
static int uart_carrier_raised(struct tty_port *port)
{
	struct uart_state *state = container_of(port, struct uart_state, port);
1636
	struct uart_port *uport;
A
Alan Cox 已提交
1637
	int mctrl;
1638 1639 1640 1641 1642 1643 1644 1645 1646 1647

	uport = uart_port_ref(state);
	/*
	 * Should never observe uport == NULL since checks for hangup should
	 * abort the tty_port_block_til_ready() loop before checking for carrier
	 * raised -- but report carrier raised if it does anyway so open will
	 * continue and not sleep
	 */
	if (WARN_ON(!uport))
		return 1;
A
Alan Cox 已提交
1648
	spin_lock_irq(&uport->lock);
1649
	uart_enable_ms(uport);
A
Alan Cox 已提交
1650 1651
	mctrl = uport->ops->get_mctrl(uport);
	spin_unlock_irq(&uport->lock);
1652
	uart_port_deref(uport);
A
Alan Cox 已提交
1653 1654 1655 1656 1657
	if (mctrl & TIOCM_CAR)
		return 1;
	return 0;
}

1658
static void uart_dtr_rts(struct tty_port *port, int raise)
A
Alan Cox 已提交
1659 1660
{
	struct uart_state *state = container_of(port, struct uart_state, port);
1661 1662 1663 1664 1665
	struct uart_port *uport;

	uport = uart_port_ref(state);
	if (!uport)
		return;
1666
	uart_port_dtr_rts(uport, raise);
1667
	uart_port_deref(uport);
A
Alan Cox 已提交
1668 1669
}

L
Linus Torvalds 已提交
1670
/*
1671 1672
 * Calls to uart_open are serialised by the tty_lock in
 *   drivers/tty/tty_io.c:tty_open()
L
Linus Torvalds 已提交
1673 1674 1675 1676 1677 1678 1679 1680 1681
 * Note that if this fails, then uart_close() _will_ be called.
 *
 * In time, we want to scrap the "opening nonpresent ports"
 * behaviour and implement an alternative way for setserial
 * to set base addresses/ports/types.  This will allow us to
 * get rid of a certain amount of extra tests.
 */
static int uart_open(struct tty_struct *tty, struct file *filp)
{
1682
	struct uart_driver *drv = tty->driver->driver_state;
L
Linus Torvalds 已提交
1683
	int retval, line = tty->index;
J
Jiri Slaby 已提交
1684
	struct uart_state *state = drv->state + line;
L
Linus Torvalds 已提交
1685

1686
	tty->driver_data = state;
L
Linus Torvalds 已提交
1687

1688 1689 1690
	retval = tty_port_open(&state->port, tty, filp);
	if (retval > 0)
		retval = 0;
1691

1692 1693 1694 1695 1696 1697 1698
	return retval;
}

static int uart_port_activate(struct tty_port *port, struct tty_struct *tty)
{
	struct uart_state *state = container_of(port, struct uart_state, port);
	struct uart_port *uport;
J
Jiri Slaby 已提交
1699

1700
	uport = uart_port_check(state);
1701 1702
	if (!uport || uport->flags & UPF_DEAD)
		return -ENXIO;
L
Linus Torvalds 已提交
1703

1704
	port->low_latency = (uport->flags & UPF_LOW_LATENCY) ? 1 : 0;
L
Linus Torvalds 已提交
1705 1706 1707 1708

	/*
	 * Start up the serial port.
	 */
1709
	return uart_startup(tty, state, 0);
L
Linus Torvalds 已提交
1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726
}

static const char *uart_type(struct uart_port *port)
{
	const char *str = NULL;

	if (port->ops->type)
		str = port->ops->type(port);

	if (!str)
		str = "unknown";

	return str;
}

#ifdef CONFIG_PROC_FS

1727
static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i)
L
Linus Torvalds 已提交
1728 1729
{
	struct uart_state *state = drv->state + i;
1730
	struct tty_port *port = &state->port;
1731
	enum uart_pm_state pm_state;
1732
	struct uart_port *uport;
L
Linus Torvalds 已提交
1733 1734
	char stat_buf[32];
	unsigned int status;
1735
	int mmio;
L
Linus Torvalds 已提交
1736

1737 1738
	mutex_lock(&port->mutex);
	uport = uart_port_check(state);
1739
	if (!uport)
1740
		goto out;
L
Linus Torvalds 已提交
1741

1742
	mmio = uport->iotype >= UPIO_MEM;
1743
	seq_printf(m, "%d: uart:%s %s%08llX irq:%d",
1744
			uport->line, uart_type(uport),
1745
			mmio ? "mmio:0x" : "port:",
1746 1747 1748
			mmio ? (unsigned long long)uport->mapbase
			     : (unsigned long long)uport->iobase,
			uport->irq);
L
Linus Torvalds 已提交
1749

1750
	if (uport->type == PORT_UNKNOWN) {
1751
		seq_putc(m, '\n');
1752
		goto out;
L
Linus Torvalds 已提交
1753 1754
	}

1755
	if (capable(CAP_SYS_ADMIN)) {
1756
		pm_state = state->pm_state;
1757 1758
		if (pm_state != UART_PM_STATE_ON)
			uart_change_pm(state, UART_PM_STATE_ON);
1759 1760 1761
		spin_lock_irq(&uport->lock);
		status = uport->ops->get_mctrl(uport);
		spin_unlock_irq(&uport->lock);
1762
		if (pm_state != UART_PM_STATE_ON)
1763
			uart_change_pm(state, pm_state);
L
Linus Torvalds 已提交
1764

1765
		seq_printf(m, " tx:%d rx:%d",
1766 1767
				uport->icount.tx, uport->icount.rx);
		if (uport->icount.frame)
1768
			seq_printf(m, " fe:%d",	uport->icount.frame);
1769
		if (uport->icount.parity)
1770
			seq_printf(m, " pe:%d",	uport->icount.parity);
1771
		if (uport->icount.brk)
1772
			seq_printf(m, " brk:%d", uport->icount.brk);
1773
		if (uport->icount.overrun)
1774
			seq_printf(m, " oe:%d", uport->icount.overrun);
1775 1776
		if (uport->icount.buf_overrun)
			seq_printf(m, " bo:%d", uport->icount.buf_overrun);
1777 1778

#define INFOBIT(bit, str) \
1779
	if (uport->mctrl & (bit)) \
L
Linus Torvalds 已提交
1780 1781
		strncat(stat_buf, (str), sizeof(stat_buf) - \
			strlen(stat_buf) - 2)
1782
#define STATBIT(bit, str) \
L
Linus Torvalds 已提交
1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796
	if (status & (bit)) \
		strncat(stat_buf, (str), sizeof(stat_buf) - \
		       strlen(stat_buf) - 2)

		stat_buf[0] = '\0';
		stat_buf[1] = '\0';
		INFOBIT(TIOCM_RTS, "|RTS");
		STATBIT(TIOCM_CTS, "|CTS");
		INFOBIT(TIOCM_DTR, "|DTR");
		STATBIT(TIOCM_DSR, "|DSR");
		STATBIT(TIOCM_CAR, "|CD");
		STATBIT(TIOCM_RNG, "|RI");
		if (stat_buf[0])
			stat_buf[0] = ' ';
1797

1798
		seq_puts(m, stat_buf);
L
Linus Torvalds 已提交
1799
	}
1800
	seq_putc(m, '\n');
L
Linus Torvalds 已提交
1801 1802
#undef STATBIT
#undef INFOBIT
1803 1804
out:
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
1805 1806
}

1807
static int uart_proc_show(struct seq_file *m, void *v)
L
Linus Torvalds 已提交
1808
{
1809
	struct tty_driver *ttydrv = m->private;
L
Linus Torvalds 已提交
1810
	struct uart_driver *drv = ttydrv->driver_state;
1811
	int i;
L
Linus Torvalds 已提交
1812

1813
	seq_printf(m, "serinfo:1.0 driver%s%s revision:%s\n", "", "", "");
1814 1815 1816
	for (i = 0; i < drv->nr; i++)
		uart_line_info(m, drv, i);
	return 0;
L
Linus Torvalds 已提交
1817 1818 1819
}
#endif

A
Andrew Morton 已提交
1820
#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(CONFIG_CONSOLE_POLL)
1821
/**
1822 1823 1824 1825
 *	uart_console_write - write a console message to a serial port
 *	@port: the port to write the message
 *	@s: array of characters
 *	@count: number of characters in string to write
1826
 *	@putchar: function to write character to port
1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841
 */
void uart_console_write(struct uart_port *port, const char *s,
			unsigned int count,
			void (*putchar)(struct uart_port *, int))
{
	unsigned int i;

	for (i = 0; i < count; i++, s++) {
		if (*s == '\n')
			putchar(port, '\r');
		putchar(port, *s);
	}
}
EXPORT_SYMBOL_GPL(uart_console_write);

L
Linus Torvalds 已提交
1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
/*
 *	Check whether an invalid uart number has been specified, and
 *	if so, search for the first available port that does have
 *	console support.
 */
struct uart_port * __init
uart_get_console(struct uart_port *ports, int nr, struct console *co)
{
	int idx = co->index;

	if (idx < 0 || idx >= nr || (ports[idx].iobase == 0 &&
				     ports[idx].membase == NULL))
		for (idx = 0; idx < nr; idx++)
			if (ports[idx].iobase != 0 ||
			    ports[idx].membase != NULL)
				break;

	co->index = idx;

	return ports + idx;
}

1864 1865 1866 1867 1868 1869 1870 1871
/**
 *	uart_parse_earlycon - Parse earlycon options
 *	@p:	  ptr to 2nd field (ie., just beyond '<name>,')
 *	@iotype:  ptr for decoded iotype (out)
 *	@addr:    ptr for decoded mapbase/iobase (out)
 *	@options: ptr for <options> field; NULL if not present (out)
 *
 *	Decodes earlycon kernel command line parameters of the form
1872 1873
 *	   earlycon=<name>,io|mmio|mmio16|mmio32|mmio32be|mmio32native,<addr>,<options>
 *	   console=<name>,io|mmio|mmio16|mmio32|mmio32be|mmio32native,<addr>,<options>
1874 1875 1876 1877 1878 1879
 *
 *	The optional form
 *	   earlycon=<name>,0x<addr>,<options>
 *	   console=<name>,0x<addr>,<options>
 *	is also accepted; the returned @iotype will be UPIO_MEM.
 *
1880
 *	Returns 0 on success or -EINVAL on failure
1881
 */
1882
int uart_parse_earlycon(char *p, unsigned char *iotype, resource_size_t *addr,
1883 1884 1885 1886 1887
			char **options)
{
	if (strncmp(p, "mmio,", 5) == 0) {
		*iotype = UPIO_MEM;
		p += 5;
1888 1889 1890
	} else if (strncmp(p, "mmio16,", 7) == 0) {
		*iotype = UPIO_MEM16;
		p += 7;
1891 1892 1893
	} else if (strncmp(p, "mmio32,", 7) == 0) {
		*iotype = UPIO_MEM32;
		p += 7;
1894 1895 1896
	} else if (strncmp(p, "mmio32be,", 9) == 0) {
		*iotype = UPIO_MEM32BE;
		p += 9;
1897 1898 1899 1900
	} else if (strncmp(p, "mmio32native,", 13) == 0) {
		*iotype = IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) ?
			UPIO_MEM32BE : UPIO_MEM32;
		p += 13;
1901 1902 1903 1904 1905 1906 1907 1908 1909
	} else if (strncmp(p, "io,", 3) == 0) {
		*iotype = UPIO_PORT;
		p += 3;
	} else if (strncmp(p, "0x", 2) == 0) {
		*iotype = UPIO_MEM;
	} else {
		return -EINVAL;
	}

1910 1911 1912 1913 1914
	/*
	 * Before you replace it with kstrtoull(), think about options separator
	 * (',') it will not tolerate
	 */
	*addr = simple_strtoull(p, NULL, 0);
1915 1916 1917 1918 1919 1920 1921 1922 1923
	p = strchr(p, ',');
	if (p)
		p++;

	*options = p;
	return 0;
}
EXPORT_SYMBOL_GPL(uart_parse_earlycon);

L
Linus Torvalds 已提交
1924
/**
1925
 *	uart_parse_options - Parse serial port baud/parity/bits/flow control.
L
Linus Torvalds 已提交
1926 1927 1928 1929 1930 1931 1932 1933 1934 1935
 *	@options: pointer to option string
 *	@baud: pointer to an 'int' variable for the baud rate.
 *	@parity: pointer to an 'int' variable for the parity.
 *	@bits: pointer to an 'int' variable for the number of data bits.
 *	@flow: pointer to an 'int' variable for the flow control character.
 *
 *	uart_parse_options decodes a string containing the serial console
 *	options.  The format of the string is <baud><parity><bits><flow>,
 *	eg: 115200n8r
 */
J
Jason Wessel 已提交
1936
void
1937 1938
uart_parse_options(const char *options, int *baud, int *parity,
		   int *bits, int *flow)
L
Linus Torvalds 已提交
1939
{
1940
	const char *s = options;
L
Linus Torvalds 已提交
1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951

	*baud = simple_strtoul(s, NULL, 10);
	while (*s >= '0' && *s <= '9')
		s++;
	if (*s)
		*parity = *s++;
	if (*s)
		*bits = *s++ - '0';
	if (*s)
		*flow = *s;
}
J
Jason Wessel 已提交
1952
EXPORT_SYMBOL_GPL(uart_parse_options);
L
Linus Torvalds 已提交
1953 1954 1955 1956 1957 1958 1959 1960 1961 1962

/**
 *	uart_set_options - setup the serial console parameters
 *	@port: pointer to the serial ports uart_port structure
 *	@co: console pointer
 *	@baud: baud rate
 *	@parity: parity character - 'n' (none), 'o' (odd), 'e' (even)
 *	@bits: number of data bits
 *	@flow: flow control character - 'r' (rts)
 */
J
Jason Wessel 已提交
1963
int
L
Linus Torvalds 已提交
1964 1965 1966
uart_set_options(struct uart_port *port, struct console *co,
		 int baud, int parity, int bits, int flow)
{
A
Alan Cox 已提交
1967
	struct ktermios termios;
1968
	static struct ktermios dummy;
L
Linus Torvalds 已提交
1969

1970 1971 1972
	/*
	 * Ensure that the serial console lock is initialised
	 * early.
1973 1974
	 * If this port is a console, then the spinlock is already
	 * initialised.
1975
	 */
1976 1977 1978 1979
	if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) {
		spin_lock_init(&port->lock);
		lockdep_set_class(&port->lock, &port_lock_key);
	}
1980

A
Alan Cox 已提交
1981
	memset(&termios, 0, sizeof(struct ktermios));
L
Linus Torvalds 已提交
1982

1983 1984
	termios.c_cflag |= CREAD | HUPCL | CLOCAL;
	tty_termios_encode_baud_rate(&termios, baud, baud);
L
Linus Torvalds 已提交
1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002

	if (bits == 7)
		termios.c_cflag |= CS7;
	else
		termios.c_cflag |= CS8;

	switch (parity) {
	case 'o': case 'O':
		termios.c_cflag |= PARODD;
		/*fall through*/
	case 'e': case 'E':
		termios.c_cflag |= PARENB;
		break;
	}

	if (flow == 'r')
		termios.c_cflag |= CRTSCTS;

2003 2004 2005 2006 2007 2008
	/*
	 * some uarts on other side don't support no flow control.
	 * So we set * DTR in host uart to make them happy
	 */
	port->mctrl |= TIOCM_DTR;

2009
	port->ops->set_termios(port, &termios, &dummy);
J
Jason Wessel 已提交
2010 2011 2012 2013 2014 2015
	/*
	 * Allow the setting of the UART parameters with a NULL console
	 * too:
	 */
	if (co)
		co->cflag = termios.c_cflag;
L
Linus Torvalds 已提交
2016 2017 2018

	return 0;
}
J
Jason Wessel 已提交
2019
EXPORT_SYMBOL_GPL(uart_set_options);
L
Linus Torvalds 已提交
2020 2021
#endif /* CONFIG_SERIAL_CORE_CONSOLE */

J
Jiri Slaby 已提交
2022 2023 2024 2025 2026 2027 2028 2029
/**
 * uart_change_pm - set power state of the port
 *
 * @state: port descriptor
 * @pm_state: new state
 *
 * Locking: port->mutex has to be held
 */
2030 2031
static void uart_change_pm(struct uart_state *state,
			   enum uart_pm_state pm_state)
L
Linus Torvalds 已提交
2032
{
2033
	struct uart_port *port = uart_port_check(state);
2034 2035

	if (state->pm_state != pm_state) {
2036
		if (port && port->ops->pm)
2037 2038 2039
			port->ops->pm(port, pm_state, state->pm_state);
		state->pm_state = pm_state;
	}
L
Linus Torvalds 已提交
2040 2041
}

G
Guennadi Liakhovetski 已提交
2042 2043 2044 2045 2046 2047 2048 2049
struct uart_match {
	struct uart_port *port;
	struct uart_driver *driver;
};

static int serial_match_port(struct device *dev, void *data)
{
	struct uart_match *match = data;
2050 2051 2052
	struct tty_driver *tty_drv = match->driver->tty_driver;
	dev_t devt = MKDEV(tty_drv->major, tty_drv->minor_start) +
		match->port->line;
G
Guennadi Liakhovetski 已提交
2053 2054 2055 2056

	return dev->devt == devt; /* Actually, only one tty per port */
}

2057
int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
L
Linus Torvalds 已提交
2058
{
2059 2060
	struct uart_state *state = drv->state + uport->line;
	struct tty_port *port = &state->port;
G
Guennadi Liakhovetski 已提交
2061
	struct device *tty_dev;
2062
	struct uart_match match = {uport, drv};
L
Linus Torvalds 已提交
2063

2064
	mutex_lock(&port->mutex);
L
Linus Torvalds 已提交
2065

2066
	tty_dev = device_find_child(uport->dev, &match, serial_match_port);
2067
	if (tty_dev && device_may_wakeup(tty_dev)) {
2068
		enable_irq_wake(uport->irq);
G
Guennadi Liakhovetski 已提交
2069
		put_device(tty_dev);
2070
		mutex_unlock(&port->mutex);
G
Guennadi Liakhovetski 已提交
2071 2072
		return 0;
	}
2073 2074
	put_device(tty_dev);

2075 2076 2077 2078 2079
	/* Nothing to do if the console is not suspending */
	if (!console_suspend_enabled && uart_console(uport))
		goto unlock;

	uport->suspended = 1;
G
Guennadi Liakhovetski 已提交
2080

2081
	if (tty_port_initialized(port)) {
2082
		const struct uart_ops *ops = uport->ops;
2083
		int tries;
L
Linus Torvalds 已提交
2084

2085
		tty_port_set_suspended(port, 1);
2086
		tty_port_set_initialized(port, 0);
2087

2088 2089 2090 2091 2092
		spin_lock_irq(&uport->lock);
		ops->stop_tx(uport);
		ops->set_mctrl(uport, 0);
		ops->stop_rx(uport);
		spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
2093 2094 2095 2096

		/*
		 * Wait for the transmitter to empty.
		 */
2097
		for (tries = 3; !ops->tx_empty(uport) && tries; tries--)
L
Linus Torvalds 已提交
2098
			msleep(10);
2099
		if (!tries)
2100 2101
			dev_err(uport->dev, "%s: Unable to drain transmitter\n",
				uport->name);
L
Linus Torvalds 已提交
2102

2103
		ops->shutdown(uport);
L
Linus Torvalds 已提交
2104 2105 2106 2107 2108
	}

	/*
	 * Disable the console device before suspending.
	 */
2109
	if (uart_console(uport))
2110
		console_stop(uport->cons);
L
Linus Torvalds 已提交
2111

2112 2113
	uart_change_pm(state, UART_PM_STATE_OFF);
unlock:
2114
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
2115 2116 2117 2118

	return 0;
}

2119
int uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
L
Linus Torvalds 已提交
2120
{
2121 2122
	struct uart_state *state = drv->state + uport->line;
	struct tty_port *port = &state->port;
2123
	struct device *tty_dev;
2124
	struct uart_match match = {uport, drv};
2125
	struct ktermios termios;
L
Linus Torvalds 已提交
2126

2127
	mutex_lock(&port->mutex);
L
Linus Torvalds 已提交
2128

2129 2130
	tty_dev = device_find_child(uport->dev, &match, serial_match_port);
	if (!uport->suspended && device_may_wakeup(tty_dev)) {
2131
		if (irqd_is_wakeup_set(irq_get_irq_data((uport->irq))))
2132
			disable_irq_wake(uport->irq);
2133
		put_device(tty_dev);
2134
		mutex_unlock(&port->mutex);
G
Guennadi Liakhovetski 已提交
2135 2136
		return 0;
	}
2137
	put_device(tty_dev);
2138
	uport->suspended = 0;
G
Guennadi Liakhovetski 已提交
2139

L
Linus Torvalds 已提交
2140 2141 2142
	/*
	 * Re-enable the console device after suspending.
	 */
2143
	if (uart_console(uport)) {
2144 2145 2146 2147 2148 2149 2150 2151 2152
		/*
		 * First try to use the console cflag setting.
		 */
		memset(&termios, 0, sizeof(struct ktermios));
		termios.c_cflag = uport->cons->cflag;

		/*
		 * If that's unset, use the tty termios setting.
		 */
2153 2154
		if (port->tty && termios.c_cflag == 0)
			termios = port->tty->termios;
2155

2156
		if (console_suspend_enabled)
2157
			uart_change_pm(state, UART_PM_STATE_ON);
2158
		uport->ops->set_termios(uport, &termios, NULL);
2159 2160
		if (console_suspend_enabled)
			console_start(uport->cons);
L
Linus Torvalds 已提交
2161 2162
	}

2163
	if (tty_port_suspended(port)) {
2164
		const struct uart_ops *ops = uport->ops;
2165
		int ret;
L
Linus Torvalds 已提交
2166

2167
		uart_change_pm(state, UART_PM_STATE_ON);
2168 2169 2170
		spin_lock_irq(&uport->lock);
		ops->set_mctrl(uport, 0);
		spin_unlock_irq(&uport->lock);
2171
		if (console_suspend_enabled || !uart_console(uport)) {
2172 2173
			/* Protected by port mutex for now */
			struct tty_struct *tty = port->tty;
2174 2175
			ret = ops->startup(uport);
			if (ret == 0) {
2176 2177
				if (tty)
					uart_change_speed(tty, state, NULL);
2178 2179 2180 2181
				spin_lock_irq(&uport->lock);
				ops->set_mctrl(uport, uport->mctrl);
				ops->start_tx(uport);
				spin_unlock_irq(&uport->lock);
2182
				tty_port_set_initialized(port, 1);
2183 2184 2185 2186 2187 2188
			} else {
				/*
				 * Failed to resume - maybe hardware went away?
				 * Clear the "initialized" flag so we won't try
				 * to call the low level drivers shutdown method.
				 */
2189
				uart_shutdown(tty, state);
2190
			}
2191
		}
2192

2193
		tty_port_set_suspended(port, 0);
L
Linus Torvalds 已提交
2194 2195
	}

2196
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
2197 2198 2199 2200 2201 2202 2203

	return 0;
}

static inline void
uart_report_port(struct uart_driver *drv, struct uart_port *port)
{
2204 2205
	char address[64];

L
Linus Torvalds 已提交
2206 2207
	switch (port->iotype) {
	case UPIO_PORT:
2208
		snprintf(address, sizeof(address), "I/O 0x%lx", port->iobase);
L
Linus Torvalds 已提交
2209 2210
		break;
	case UPIO_HUB6:
2211
		snprintf(address, sizeof(address),
2212
			 "I/O 0x%lx offset 0x%x", port->iobase, port->hub6);
L
Linus Torvalds 已提交
2213 2214
		break;
	case UPIO_MEM:
2215
	case UPIO_MEM16:
L
Linus Torvalds 已提交
2216
	case UPIO_MEM32:
2217
	case UPIO_MEM32BE:
2218
	case UPIO_AU:
2219
	case UPIO_TSI:
2220
		snprintf(address, sizeof(address),
2221
			 "MMIO 0x%llx", (unsigned long long)port->mapbase);
2222 2223 2224
		break;
	default:
		strlcpy(address, "*unknown*", sizeof(address));
L
Linus Torvalds 已提交
2225 2226
		break;
	}
2227

2228
	pr_info("%s%s%s at %s (irq = %d, base_baud = %d) is a %s\n",
J
James Bottomley 已提交
2229 2230
	       port->dev ? dev_name(port->dev) : "",
	       port->dev ? ": " : "",
2231
	       port->name,
2232
	       address, port->irq, port->uartclk / 16, uart_type(port));
L
Linus Torvalds 已提交
2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250
}

static void
uart_configure_port(struct uart_driver *drv, struct uart_state *state,
		    struct uart_port *port)
{
	unsigned int flags;

	/*
	 * If there isn't a port here, don't do anything further.
	 */
	if (!port->iobase && !port->mapbase && !port->membase)
		return;

	/*
	 * Now do the auto configuration stuff.  Note that config_port
	 * is expected to claim the resources and map the port for us.
	 */
2251
	flags = 0;
L
Linus Torvalds 已提交
2252 2253 2254
	if (port->flags & UPF_AUTO_IRQ)
		flags |= UART_CONFIG_IRQ;
	if (port->flags & UPF_BOOT_AUTOCONF) {
2255 2256 2257 2258
		if (!(port->flags & UPF_FIXED_TYPE)) {
			port->type = PORT_UNKNOWN;
			flags |= UART_CONFIG_TYPE;
		}
L
Linus Torvalds 已提交
2259 2260 2261 2262 2263 2264 2265 2266
		port->ops->config_port(port, flags);
	}

	if (port->type != PORT_UNKNOWN) {
		unsigned long flags;

		uart_report_port(drv, port);

2267
		/* Power up port for set_mctrl() */
2268
		uart_change_pm(state, UART_PM_STATE_ON);
2269

L
Linus Torvalds 已提交
2270 2271
		/*
		 * Ensure that the modem control lines are de-activated.
2272
		 * keep the DTR setting that is set in uart_set_options()
L
Linus Torvalds 已提交
2273 2274 2275
		 * We probably don't need a spinlock around this, but
		 */
		spin_lock_irqsave(&port->lock, flags);
2276
		port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR);
L
Linus Torvalds 已提交
2277 2278
		spin_unlock_irqrestore(&port->lock, flags);

2279 2280 2281 2282 2283 2284 2285 2286
		/*
		 * If this driver supports console, and it hasn't been
		 * successfully registered yet, try to re-register it.
		 * It may be that the port was not available.
		 */
		if (port->cons && !(port->cons->flags & CON_ENABLED))
			register_console(port->cons);

L
Linus Torvalds 已提交
2287 2288 2289 2290 2291
		/*
		 * Power down all ports by default, except the
		 * console if we have one.
		 */
		if (!uart_console(port))
2292
			uart_change_pm(state, UART_PM_STATE_OFF);
L
Linus Torvalds 已提交
2293 2294 2295
	}
}

J
Jason Wessel 已提交
2296 2297 2298 2299 2300 2301
#ifdef CONFIG_CONSOLE_POLL

static int uart_poll_init(struct tty_driver *driver, int line, char *options)
{
	struct uart_driver *drv = driver->driver_state;
	struct uart_state *state = drv->state + line;
2302
	struct tty_port *tport;
J
Jason Wessel 已提交
2303 2304 2305 2306 2307
	struct uart_port *port;
	int baud = 9600;
	int bits = 8;
	int parity = 'n';
	int flow = 'n';
2308
	int ret = 0;
J
Jason Wessel 已提交
2309

2310 2311 2312
	tport = &state->port;
	mutex_lock(&tport->mutex);

2313 2314
	port = uart_port_check(state);
	if (!port || !(port->ops->poll_get_char && port->ops->poll_put_char)) {
2315 2316 2317
		ret = -1;
		goto out;
	}
J
Jason Wessel 已提交
2318

2319 2320
	if (port->ops->poll_init) {
		/*
2321 2322
		 * We don't set initialized as we only initialized the hw,
		 * e.g. state->xmit is still uninitialized.
2323
		 */
2324
		if (!tty_port_initialized(tport))
2325 2326 2327
			ret = port->ops->poll_init(port);
	}

2328
	if (!ret && options) {
J
Jason Wessel 已提交
2329
		uart_parse_options(options, &baud, &parity, &bits, &flow);
2330
		ret = uart_set_options(port, NULL, baud, parity, bits, flow);
J
Jason Wessel 已提交
2331
	}
2332 2333 2334
out:
	mutex_unlock(&tport->mutex);
	return ret;
J
Jason Wessel 已提交
2335 2336 2337 2338 2339 2340 2341
}

static int uart_poll_get_char(struct tty_driver *driver, int line)
{
	struct uart_driver *drv = driver->driver_state;
	struct uart_state *state = drv->state + line;
	struct uart_port *port;
2342
	int ret = -1;
J
Jason Wessel 已提交
2343

2344 2345 2346 2347
	port = uart_port_ref(state);
	if (port) {
		ret = port->ops->poll_get_char(port);
		uart_port_deref(port);
2348
	}
2349

2350
	return ret;
J
Jason Wessel 已提交
2351 2352 2353 2354 2355 2356 2357 2358
}

static void uart_poll_put_char(struct tty_driver *driver, int line, char ch)
{
	struct uart_driver *drv = driver->driver_state;
	struct uart_state *state = drv->state + line;
	struct uart_port *port;

2359 2360 2361
	port = uart_port_ref(state);
	if (!port)
		return;
2362 2363 2364

	if (ch == '\n')
		port->ops->poll_put_char(port, '\r');
J
Jason Wessel 已提交
2365
	port->ops->poll_put_char(port, ch);
2366
	uart_port_deref(port);
J
Jason Wessel 已提交
2367 2368 2369
}
#endif

J
Jeff Dike 已提交
2370
static const struct tty_operations uart_ops = {
L
Linus Torvalds 已提交
2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383
	.open		= uart_open,
	.close		= uart_close,
	.write		= uart_write,
	.put_char	= uart_put_char,
	.flush_chars	= uart_flush_chars,
	.write_room	= uart_write_room,
	.chars_in_buffer= uart_chars_in_buffer,
	.flush_buffer	= uart_flush_buffer,
	.ioctl		= uart_ioctl,
	.throttle	= uart_throttle,
	.unthrottle	= uart_unthrottle,
	.send_xchar	= uart_send_xchar,
	.set_termios	= uart_set_termios,
2384
	.set_ldisc	= uart_set_ldisc,
L
Linus Torvalds 已提交
2385 2386 2387 2388 2389 2390
	.stop		= uart_stop,
	.start		= uart_start,
	.hangup		= uart_hangup,
	.break_ctl	= uart_break_ctl,
	.wait_until_sent= uart_wait_until_sent,
#ifdef CONFIG_PROC_FS
2391
	.proc_show	= uart_proc_show,
L
Linus Torvalds 已提交
2392 2393 2394
#endif
	.tiocmget	= uart_tiocmget,
	.tiocmset	= uart_tiocmset,
A
Al Viro 已提交
2395 2396
	.set_serial	= uart_set_info_user,
	.get_serial	= uart_get_info_user,
A
Alan Cox 已提交
2397
	.get_icount	= uart_get_icount,
J
Jason Wessel 已提交
2398 2399 2400 2401 2402
#ifdef CONFIG_CONSOLE_POLL
	.poll_init	= uart_poll_init,
	.poll_get_char	= uart_poll_get_char,
	.poll_put_char	= uart_poll_put_char,
#endif
L
Linus Torvalds 已提交
2403 2404
};

A
Alan Cox 已提交
2405 2406 2407
static const struct tty_port_operations uart_port_ops = {
	.carrier_raised = uart_carrier_raised,
	.dtr_rts	= uart_dtr_rts,
2408
	.activate	= uart_port_activate,
2409
	.shutdown	= uart_tty_port_shutdown,
A
Alan Cox 已提交
2410 2411
};

L
Linus Torvalds 已提交
2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426
/**
 *	uart_register_driver - register a driver with the uart core layer
 *	@drv: low level driver structure
 *
 *	Register a uart driver with the core driver.  We in turn register
 *	with the tty layer, and initialise the core driver per-port state.
 *
 *	We have a proc file in /proc/tty/driver which is named after the
 *	normal driver.
 *
 *	drv->port should be NULL, and the per-port structures should be
 *	registered using uart_add_one_port after this call has succeeded.
 */
int uart_register_driver(struct uart_driver *drv)
{
2427
	struct tty_driver *normal;
L
Linus Torvalds 已提交
2428 2429 2430 2431 2432 2433 2434 2435
	int i, retval;

	BUG_ON(drv->state);

	/*
	 * Maybe we should be using a slab cache for this, especially if
	 * we have a large number of ports to handle.
	 */
K
Kees Cook 已提交
2436
	drv->state = kcalloc(drv->nr, sizeof(struct uart_state), GFP_KERNEL);
L
Linus Torvalds 已提交
2437 2438 2439
	if (!drv->state)
		goto out;

2440
	normal = alloc_tty_driver(drv->nr);
L
Linus Torvalds 已提交
2441
	if (!normal)
2442
		goto out_kfree;
L
Linus Torvalds 已提交
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453

	drv->tty_driver = normal;

	normal->driver_name	= drv->driver_name;
	normal->name		= drv->dev_name;
	normal->major		= drv->major;
	normal->minor_start	= drv->minor;
	normal->type		= TTY_DRIVER_TYPE_SERIAL;
	normal->subtype		= SERIAL_TYPE_NORMAL;
	normal->init_termios	= tty_std_termios;
	normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
A
Alan Cox 已提交
2454
	normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
2455
	normal->flags		= TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
L
Linus Torvalds 已提交
2456 2457 2458 2459 2460 2461 2462 2463
	normal->driver_state    = drv;
	tty_set_operations(normal, &uart_ops);

	/*
	 * Initialise the UART state(s).
	 */
	for (i = 0; i < drv->nr; i++) {
		struct uart_state *state = drv->state + i;
2464
		struct tty_port *port = &state->port;
L
Linus Torvalds 已提交
2465

2466
		tty_port_init(port);
A
Alan Cox 已提交
2467
		port->ops = &uart_port_ops;
L
Linus Torvalds 已提交
2468 2469 2470
	}

	retval = tty_register_driver(normal);
2471 2472 2473
	if (retval >= 0)
		return retval;

2474 2475
	for (i = 0; i < drv->nr; i++)
		tty_port_destroy(&drv->state[i].port);
2476 2477 2478 2479 2480
	put_tty_driver(normal);
out_kfree:
	kfree(drv->state);
out:
	return -ENOMEM;
L
Linus Torvalds 已提交
2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494
}

/**
 *	uart_unregister_driver - remove a driver from the uart core layer
 *	@drv: low level driver structure
 *
 *	Remove all references to a driver from the core driver.  The low
 *	level driver must have removed all its ports via the
 *	uart_remove_one_port() if it registered them with uart_add_one_port().
 *	(ie, drv->port == NULL)
 */
void uart_unregister_driver(struct uart_driver *drv)
{
	struct tty_driver *p = drv->tty_driver;
2495 2496
	unsigned int i;

L
Linus Torvalds 已提交
2497 2498
	tty_unregister_driver(p);
	put_tty_driver(p);
2499 2500
	for (i = 0; i < drv->nr; i++)
		tty_port_destroy(&drv->state[i].port);
L
Linus Torvalds 已提交
2501
	kfree(drv->state);
2502
	drv->state = NULL;
L
Linus Torvalds 已提交
2503 2504 2505 2506 2507 2508 2509 2510 2511 2512
	drv->tty_driver = NULL;
}

struct tty_driver *uart_console_device(struct console *co, int *index)
{
	struct uart_driver *p = co->data;
	*index = co->index;
	return p->tty_driver;
}

2513 2514 2515
static ssize_t uart_get_attr_uartclk(struct device *dev,
	struct device_attribute *attr, char *buf)
{
2516
	struct serial_struct tmp;
2517 2518
	struct tty_port *port = dev_get_drvdata(dev);

A
Alan Cox 已提交
2519
	uart_get_info(port, &tmp);
2520
	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.baud_base * 16);
2521 2522
}

2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546
static ssize_t uart_get_attr_type(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);

	uart_get_info(port, &tmp);
	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.type);
}
static ssize_t uart_get_attr_line(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);

	uart_get_info(port, &tmp);
	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.line);
}

static ssize_t uart_get_attr_port(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);
2547
	unsigned long ioaddr;
2548 2549

	uart_get_info(port, &tmp);
2550 2551 2552 2553
	ioaddr = tmp.port;
	if (HIGH_BITS_OFFSET)
		ioaddr |= (unsigned long)tmp.port_high << HIGH_BITS_OFFSET;
	return snprintf(buf, PAGE_SIZE, "0x%lX\n", ioaddr);
2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653
}

static ssize_t uart_get_attr_irq(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);

	uart_get_info(port, &tmp);
	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.irq);
}

static ssize_t uart_get_attr_flags(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);

	uart_get_info(port, &tmp);
	return snprintf(buf, PAGE_SIZE, "0x%X\n", tmp.flags);
}

static ssize_t uart_get_attr_xmit_fifo_size(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);

	uart_get_info(port, &tmp);
	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.xmit_fifo_size);
}


static ssize_t uart_get_attr_close_delay(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);

	uart_get_info(port, &tmp);
	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.close_delay);
}


static ssize_t uart_get_attr_closing_wait(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);

	uart_get_info(port, &tmp);
	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.closing_wait);
}

static ssize_t uart_get_attr_custom_divisor(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);

	uart_get_info(port, &tmp);
	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.custom_divisor);
}

static ssize_t uart_get_attr_io_type(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);

	uart_get_info(port, &tmp);
	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.io_type);
}

static ssize_t uart_get_attr_iomem_base(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);

	uart_get_info(port, &tmp);
	return snprintf(buf, PAGE_SIZE, "0x%lX\n", (unsigned long)tmp.iomem_base);
}

static ssize_t uart_get_attr_iomem_reg_shift(struct device *dev,
	struct device_attribute *attr, char *buf)
{
	struct serial_struct tmp;
	struct tty_port *port = dev_get_drvdata(dev);

	uart_get_info(port, &tmp);
	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.iomem_reg_shift);
}

static DEVICE_ATTR(type, S_IRUSR | S_IRGRP, uart_get_attr_type, NULL);
static DEVICE_ATTR(line, S_IRUSR | S_IRGRP, uart_get_attr_line, NULL);
static DEVICE_ATTR(port, S_IRUSR | S_IRGRP, uart_get_attr_port, NULL);
static DEVICE_ATTR(irq, S_IRUSR | S_IRGRP, uart_get_attr_irq, NULL);
static DEVICE_ATTR(flags, S_IRUSR | S_IRGRP, uart_get_attr_flags, NULL);
static DEVICE_ATTR(xmit_fifo_size, S_IRUSR | S_IRGRP, uart_get_attr_xmit_fifo_size, NULL);
2654
static DEVICE_ATTR(uartclk, S_IRUSR | S_IRGRP, uart_get_attr_uartclk, NULL);
2655 2656 2657 2658 2659 2660
static DEVICE_ATTR(close_delay, S_IRUSR | S_IRGRP, uart_get_attr_close_delay, NULL);
static DEVICE_ATTR(closing_wait, S_IRUSR | S_IRGRP, uart_get_attr_closing_wait, NULL);
static DEVICE_ATTR(custom_divisor, S_IRUSR | S_IRGRP, uart_get_attr_custom_divisor, NULL);
static DEVICE_ATTR(io_type, S_IRUSR | S_IRGRP, uart_get_attr_io_type, NULL);
static DEVICE_ATTR(iomem_base, S_IRUSR | S_IRGRP, uart_get_attr_iomem_base, NULL);
static DEVICE_ATTR(iomem_reg_shift, S_IRUSR | S_IRGRP, uart_get_attr_iomem_reg_shift, NULL);
2661 2662

static struct attribute *tty_dev_attrs[] = {
2663 2664 2665 2666 2667 2668
	&dev_attr_type.attr,
	&dev_attr_line.attr,
	&dev_attr_port.attr,
	&dev_attr_irq.attr,
	&dev_attr_flags.attr,
	&dev_attr_xmit_fifo_size.attr,
2669
	&dev_attr_uartclk.attr,
2670 2671 2672 2673 2674 2675
	&dev_attr_close_delay.attr,
	&dev_attr_closing_wait.attr,
	&dev_attr_custom_divisor.attr,
	&dev_attr_io_type.attr,
	&dev_attr_iomem_base.attr,
	&dev_attr_iomem_reg_shift.attr,
2676 2677 2678
	NULL,
	};

2679
static const struct attribute_group tty_dev_attr_group = {
2680 2681 2682
	.attrs = tty_dev_attrs,
	};

L
Linus Torvalds 已提交
2683 2684 2685
/**
 *	uart_add_one_port - attach a driver-defined port structure
 *	@drv: pointer to the uart low level driver structure for this port
2686
 *	@uport: uart port structure to use for this port.
L
Linus Torvalds 已提交
2687 2688 2689 2690 2691 2692
 *
 *	This allows the driver to register its own uart_port structure
 *	with the core driver.  The main purpose is to allow the low
 *	level uart drivers to expand uart_port, rather than having yet
 *	more levels of structures.
 */
2693
int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
L
Linus Torvalds 已提交
2694 2695
{
	struct uart_state *state;
2696
	struct tty_port *port;
L
Linus Torvalds 已提交
2697
	int ret = 0;
G
Guennadi Liakhovetski 已提交
2698
	struct device *tty_dev;
2699
	int num_groups;
L
Linus Torvalds 已提交
2700 2701 2702

	BUG_ON(in_interrupt());

2703
	if (uport->line >= drv->nr)
L
Linus Torvalds 已提交
2704 2705
		return -EINVAL;

2706 2707
	state = drv->state + uport->line;
	port = &state->port;
L
Linus Torvalds 已提交
2708

2709
	mutex_lock(&port_mutex);
2710
	mutex_lock(&port->mutex);
A
Alan Cox 已提交
2711
	if (state->uart_port) {
L
Linus Torvalds 已提交
2712 2713 2714 2715
		ret = -EINVAL;
		goto out;
	}

2716
	/* Link the port to the driver state table and vice versa */
2717 2718
	atomic_set(&state->refcount, 1);
	init_waitqueue_head(&state->remove_wait);
2719
	state->uart_port = uport;
2720
	uport->state = state;
L
Linus Torvalds 已提交
2721

2722
	state->pm_state = UART_PM_STATE_UNDEFINED;
2723
	uport->cons = drv->cons;
2724
	uport->minor = drv->tty_driver->minor_start + uport->line;
2725 2726 2727 2728 2729 2730
	uport->name = kasprintf(GFP_KERNEL, "%s%d", drv->dev_name,
				drv->tty_driver->name_base + uport->line);
	if (!uport->name) {
		ret = -ENOMEM;
		goto out;
	}
L
Linus Torvalds 已提交
2731

2732 2733 2734 2735
	/*
	 * If this port is a console, then the spinlock is already
	 * initialised.
	 */
2736 2737 2738
	if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) {
		spin_lock_init(&uport->lock);
		lockdep_set_class(&uport->lock, &port_lock_key);
I
Ingo Molnar 已提交
2739
	}
2740 2741
	if (uport->cons && uport->dev)
		of_console_check(uport->dev->of_node, uport->cons->name, uport->line);
2742

2743
	uart_configure_port(drv, state, uport);
L
Linus Torvalds 已提交
2744

2745 2746
	port->console = uart_console(uport);

2747 2748 2749 2750
	num_groups = 2;
	if (uport->attr_group)
		num_groups++;

2751
	uport->tty_groups = kcalloc(num_groups, sizeof(*uport->tty_groups),
2752 2753 2754 2755 2756 2757 2758 2759 2760
				    GFP_KERNEL);
	if (!uport->tty_groups) {
		ret = -ENOMEM;
		goto out;
	}
	uport->tty_groups[0] = &tty_dev_attr_group;
	if (uport->attr_group)
		uport->tty_groups[1] = uport->attr_group;

L
Linus Torvalds 已提交
2761 2762
	/*
	 * Register the port whether it's detected or not.  This allows
2763
	 * setserial to be used to alter this port's parameters.
L
Linus Torvalds 已提交
2764
	 */
J
Johan Hovold 已提交
2765
	tty_dev = tty_port_register_device_attr_serdev(port, drv->tty_driver,
2766
			uport->line, uport->dev, port, uport->tty_groups);
G
Guennadi Liakhovetski 已提交
2767
	if (likely(!IS_ERR(tty_dev))) {
2768 2769
		device_set_wakeup_capable(tty_dev, 1);
	} else {
2770
		dev_err(uport->dev, "Cannot register tty device on line %d\n",
2771
		       uport->line);
2772
	}
L
Linus Torvalds 已提交
2773

2774 2775 2776
	/*
	 * Ensure UPF_DEAD is not set.
	 */
2777
	uport->flags &= ~UPF_DEAD;
2778

L
Linus Torvalds 已提交
2779
 out:
2780
	mutex_unlock(&port->mutex);
2781
	mutex_unlock(&port_mutex);
L
Linus Torvalds 已提交
2782 2783 2784 2785 2786 2787 2788

	return ret;
}

/**
 *	uart_remove_one_port - detach a driver defined port structure
 *	@drv: pointer to the uart low level driver structure for this port
2789
 *	@uport: uart port structure for this port
L
Linus Torvalds 已提交
2790 2791 2792 2793 2794
 *
 *	This unhooks (and hangs up) the specified port structure from the
 *	core driver.  No further calls will be made to the low-level code
 *	for this port.
 */
2795
int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
L
Linus Torvalds 已提交
2796
{
2797 2798
	struct uart_state *state = drv->state + uport->line;
	struct tty_port *port = &state->port;
2799
	struct uart_port *uart_port;
2800
	struct tty_struct *tty;
2801
	int ret = 0;
L
Linus Torvalds 已提交
2802 2803 2804

	BUG_ON(in_interrupt());

2805
	mutex_lock(&port_mutex);
L
Linus Torvalds 已提交
2806

2807 2808 2809 2810
	/*
	 * Mark the port "dead" - this prevents any opens from
	 * succeeding while we shut down the port.
	 */
2811
	mutex_lock(&port->mutex);
2812 2813 2814 2815 2816 2817
	uart_port = uart_port_check(state);
	if (uart_port != uport)
		dev_alert(uport->dev, "Removing wrong port: %p != %p\n",
			  uart_port, uport);

	if (!uart_port) {
2818 2819 2820 2821
		mutex_unlock(&port->mutex);
		ret = -EINVAL;
		goto out;
	}
2822 2823
	uport->flags |= UPF_DEAD;
	mutex_unlock(&port->mutex);
2824

L
Linus Torvalds 已提交
2825
	/*
2826
	 * Remove the devices from the tty layer
L
Linus Torvalds 已提交
2827
	 */
J
Johan Hovold 已提交
2828
	tty_port_unregister_device(port, drv->tty_driver, uport->line);
L
Linus Torvalds 已提交
2829

2830 2831
	tty = tty_port_tty_get(port);
	if (tty) {
2832
		tty_vhangup(port->tty);
2833 2834
		tty_kref_put(tty);
	}
2835

2836 2837 2838 2839 2840 2841
	/*
	 * If the port is used as a console, unregister it
	 */
	if (uart_console(uport))
		unregister_console(uport->cons);

2842 2843 2844
	/*
	 * Free the port IO and memory resources, if any.
	 */
2845
	if (uport->type != PORT_UNKNOWN && uport->ops->release_port)
2846
		uport->ops->release_port(uport);
2847
	kfree(uport->tty_groups);
2848
	kfree(uport->name);
2849 2850 2851 2852

	/*
	 * Indicate that there isn't a port here anymore.
	 */
2853
	uport->type = PORT_UNKNOWN;
2854

2855
	mutex_lock(&port->mutex);
2856 2857
	WARN_ON(atomic_dec_return(&state->refcount) < 0);
	wait_event(state->remove_wait, !atomic_read(&state->refcount));
A
Alan Cox 已提交
2858
	state->uart_port = NULL;
2859
	mutex_unlock(&port->mutex);
2860
out:
2861
	mutex_unlock(&port_mutex);
L
Linus Torvalds 已提交
2862

2863
	return ret;
L
Linus Torvalds 已提交
2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880
}

/*
 *	Are the two ports equivalent?
 */
int uart_match_port(struct uart_port *port1, struct uart_port *port2)
{
	if (port1->iotype != port2->iotype)
		return 0;

	switch (port1->iotype) {
	case UPIO_PORT:
		return (port1->iobase == port2->iobase);
	case UPIO_HUB6:
		return (port1->iobase == port2->iobase) &&
		       (port1->hub6   == port2->hub6);
	case UPIO_MEM:
2881
	case UPIO_MEM16:
2882
	case UPIO_MEM32:
2883
	case UPIO_MEM32BE:
2884 2885
	case UPIO_AU:
	case UPIO_TSI:
2886
		return (port1->mapbase == port2->mapbase);
L
Linus Torvalds 已提交
2887 2888 2889 2890 2891
	}
	return 0;
}
EXPORT_SYMBOL(uart_match_port);

J
Jiri Slaby 已提交
2892 2893 2894 2895
/**
 *	uart_handle_dcd_change - handle a change of carrier detect state
 *	@uport: uart_port structure for the open port
 *	@status: new carrier detect status, nonzero if active
2896 2897
 *
 *	Caller must hold uport->lock
J
Jiri Slaby 已提交
2898 2899 2900
 */
void uart_handle_dcd_change(struct uart_port *uport, unsigned int status)
{
2901
	struct tty_port *port = &uport->state->port;
2902
	struct tty_struct *tty = port->tty;
2903
	struct tty_ldisc *ld;
J
Jiri Slaby 已提交
2904

2905 2906
	lockdep_assert_held_once(&uport->lock);

2907 2908 2909 2910 2911 2912 2913
	if (tty) {
		ld = tty_ldisc_ref(tty);
		if (ld) {
			if (ld->ops->dcd_change)
				ld->ops->dcd_change(tty, status);
			tty_ldisc_deref(ld);
		}
2914
	}
J
Jiri Slaby 已提交
2915 2916 2917

	uport->icount.dcd++;

2918
	if (uart_dcd_enabled(uport)) {
J
Jiri Slaby 已提交
2919 2920
		if (status)
			wake_up_interruptible(&port->open_wait);
2921 2922
		else if (tty)
			tty_hangup(tty);
J
Jiri Slaby 已提交
2923 2924 2925 2926 2927 2928 2929 2930
	}
}
EXPORT_SYMBOL_GPL(uart_handle_dcd_change);

/**
 *	uart_handle_cts_change - handle a change of clear-to-send state
 *	@uport: uart_port structure for the open port
 *	@status: new clear to send status, nonzero if active
2931 2932
 *
 *	Caller must hold uport->lock
J
Jiri Slaby 已提交
2933 2934 2935
 */
void uart_handle_cts_change(struct uart_port *uport, unsigned int status)
{
2936 2937
	lockdep_assert_held_once(&uport->lock);

J
Jiri Slaby 已提交
2938 2939
	uport->icount.cts++;

2940
	if (uart_softcts_mode(uport)) {
2941
		if (uport->hw_stopped) {
J
Jiri Slaby 已提交
2942
			if (status) {
2943
				uport->hw_stopped = 0;
J
Jiri Slaby 已提交
2944 2945 2946 2947 2948
				uport->ops->start_tx(uport);
				uart_write_wakeup(uport);
			}
		} else {
			if (!status) {
2949
				uport->hw_stopped = 1;
J
Jiri Slaby 已提交
2950 2951 2952
				uport->ops->stop_tx(uport);
			}
		}
2953

J
Jiri Slaby 已提交
2954 2955 2956 2957
	}
}
EXPORT_SYMBOL_GPL(uart_handle_cts_change);

J
Jiri Slaby 已提交
2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969
/**
 * uart_insert_char - push a char to the uart layer
 *
 * User is responsible to call tty_flip_buffer_push when they are done with
 * insertion.
 *
 * @port: corresponding port
 * @status: state of the serial port RX buffer (LSR for 8250)
 * @overrun: mask of overrun bits in @status
 * @ch: character to push
 * @flag: flag for the character (see TTY_NORMAL and friends)
 */
J
Jiri Slaby 已提交
2970 2971 2972
void uart_insert_char(struct uart_port *port, unsigned int status,
		 unsigned int overrun, unsigned int ch, unsigned int flag)
{
J
Jiri Slaby 已提交
2973
	struct tty_port *tport = &port->state->port;
J
Jiri Slaby 已提交
2974 2975

	if ((status & port->ignore_status_mask & ~overrun) == 0)
J
Jiri Slaby 已提交
2976
		if (tty_insert_flip_char(tport, ch, flag) == 0)
2977
			++port->icount.buf_overrun;
J
Jiri Slaby 已提交
2978 2979 2980 2981 2982 2983

	/*
	 * Overrun is special.  Since it's reported immediately,
	 * it doesn't affect the current character.
	 */
	if (status & ~port->ignore_status_mask & overrun)
J
Jiri Slaby 已提交
2984
		if (tty_insert_flip_char(tport, 0, TTY_OVERRUN) == 0)
2985
			++port->icount.buf_overrun;
J
Jiri Slaby 已提交
2986 2987 2988
}
EXPORT_SYMBOL_GPL(uart_insert_char);

L
Linus Torvalds 已提交
2989 2990 2991 2992 2993 2994 2995 2996
EXPORT_SYMBOL(uart_write_wakeup);
EXPORT_SYMBOL(uart_register_driver);
EXPORT_SYMBOL(uart_unregister_driver);
EXPORT_SYMBOL(uart_suspend_port);
EXPORT_SYMBOL(uart_resume_port);
EXPORT_SYMBOL(uart_add_one_port);
EXPORT_SYMBOL(uart_remove_one_port);

2997
/**
2998 2999
 * uart_get_rs485_mode() - retrieve rs485 properties for given uart
 * @dev: uart device
3000 3001 3002 3003 3004
 * @rs485conf: output parameter
 *
 * This function implements the device tree binding described in
 * Documentation/devicetree/bindings/serial/rs485.txt.
 */
3005
void uart_get_rs485_mode(struct device *dev, struct serial_rs485 *rs485conf)
3006 3007 3008 3009
{
	u32 rs485_delay[2];
	int ret;

3010 3011
	ret = device_property_read_u32_array(dev, "rs485-rts-delay",
					     rs485_delay, 2);
3012 3013 3014 3015 3016 3017 3018 3019 3020
	if (!ret) {
		rs485conf->delay_rts_before_send = rs485_delay[0];
		rs485conf->delay_rts_after_send = rs485_delay[1];
	} else {
		rs485conf->delay_rts_before_send = 0;
		rs485conf->delay_rts_after_send = 0;
	}

	/*
3021 3022
	 * Clear full-duplex and enabled flags, set RTS polarity to active high
	 * to get to a defined state with the following properties:
3023
	 */
3024 3025 3026
	rs485conf->flags &= ~(SER_RS485_RX_DURING_TX | SER_RS485_ENABLED |
			      SER_RS485_RTS_AFTER_SEND);
	rs485conf->flags |= SER_RS485_RTS_ON_SEND;
3027

3028
	if (device_property_read_bool(dev, "rs485-rx-during-tx"))
3029 3030
		rs485conf->flags |= SER_RS485_RX_DURING_TX;

3031
	if (device_property_read_bool(dev, "linux,rs485-enabled-at-boot-time"))
3032
		rs485conf->flags |= SER_RS485_ENABLED;
3033 3034 3035 3036 3037

	if (device_property_read_bool(dev, "rs485-rts-active-low")) {
		rs485conf->flags &= ~SER_RS485_RTS_ON_SEND;
		rs485conf->flags |= SER_RS485_RTS_AFTER_SEND;
	}
3038
}
3039
EXPORT_SYMBOL_GPL(uart_get_rs485_mode);
3040

L
Linus Torvalds 已提交
3041 3042
MODULE_DESCRIPTION("Serial driver core");
MODULE_LICENSE("GPL");