serial_core.c 71.4 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
/*
 *  Driver core for serial ports
 *
 *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
 *
 *  Copyright 1999 ARM Limited
 *  Copyright (C) 2000-2001 Deep Blue Solutions Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include <linux/module.h>
#include <linux/tty.h>
J
Jiri Slaby 已提交
25
#include <linux/tty_flip.h>
L
Linus Torvalds 已提交
26 27 28
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/console.h>
29
#include <linux/of.h>
30 31
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
L
Linus Torvalds 已提交
32 33
#include <linux/device.h>
#include <linux/serial.h> /* for serial_state and serial_icounter_struct */
34
#include <linux/serial_core.h>
L
Linus Torvalds 已提交
35
#include <linux/delay.h>
36
#include <linux/mutex.h>
L
Linus Torvalds 已提交
37 38 39 40 41 42 43

#include <asm/irq.h>
#include <asm/uaccess.h>

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

I
Ingo Molnar 已提交
46 47 48 49 50 51
/*
 * 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 已提交
52 53
#define HIGH_BITS_OFFSET	((sizeof(long)-sizeof(int))*8)

54
static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
55
					struct ktermios *old_termios);
56
static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
57 58
static void uart_change_pm(struct uart_state *state,
			   enum uart_pm_state pm_state);
L
Linus Torvalds 已提交
59

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

62 63
static int uart_dcd_enabled(struct uart_port *uport)
{
64
	return !!(uport->status & UPSTAT_DCD_ENABLE);
65 66
}

L
Linus Torvalds 已提交
67 68 69 70 71 72
/*
 * 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 已提交
73
	struct uart_state *state = port->state;
74 75 76 77
	/*
	 * This means you called this function _after_ the port was
	 * closed.  No cookie for you.
	 */
A
Alan Cox 已提交
78
	BUG_ON(!state);
79
	tty_wakeup(state->port.tty);
L
Linus Torvalds 已提交
80 81 82 83 84
}

static void uart_stop(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
A
Alan Cox 已提交
85
	struct uart_port *port = state->uart_port;
L
Linus Torvalds 已提交
86 87 88
	unsigned long flags;

	spin_lock_irqsave(&port->lock, flags);
89
	port->ops->stop_tx(port);
L
Linus Torvalds 已提交
90 91 92 93 94 95
	spin_unlock_irqrestore(&port->lock, flags);
}

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

98
	if (!uart_tx_stopped(port))
99
		port->ops->start_tx(port);
L
Linus Torvalds 已提交
100 101 102 103 104
}

static void uart_start(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
A
Alan Cox 已提交
105
	struct uart_port *port = state->uart_port;
L
Linus Torvalds 已提交
106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126
	unsigned long flags;

	spin_lock_irqsave(&port->lock, flags);
	__uart_start(tty);
	spin_unlock_irqrestore(&port->lock, flags);
}

static inline void
uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
{
	unsigned long flags;
	unsigned int old;

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

127 128
#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 已提交
129 130 131

/*
 * Startup the port.  This will be called once per open.  All calls
A
Alan Cox 已提交
132
 * will be serialised by the per-port mutex.
L
Linus Torvalds 已提交
133
 */
134 135
static int uart_port_startup(struct tty_struct *tty, struct uart_state *state,
		int init_hw)
L
Linus Torvalds 已提交
136
{
137
	struct uart_port *uport = state->uart_port;
L
Linus Torvalds 已提交
138 139 140
	unsigned long page;
	int retval = 0;

141
	if (uport->type == PORT_UNKNOWN)
142
		return 1;
L
Linus Torvalds 已提交
143

144 145 146 147 148
	/*
	 * Make sure the device is in D0 state.
	 */
	uart_change_pm(state, UART_PM_STATE_ON);

L
Linus Torvalds 已提交
149 150 151 152
	/*
	 * Initialise and allocate the transmit and temporary
	 * buffer.
	 */
A
Alan Cox 已提交
153
	if (!state->xmit.buf) {
A
Alan Cox 已提交
154
		/* This is protected by the per port mutex */
L
Linus Torvalds 已提交
155 156 157 158
		page = get_zeroed_page(GFP_KERNEL);
		if (!page)
			return -ENOMEM;

A
Alan Cox 已提交
159 160
		state->xmit.buf = (unsigned char *) page;
		uart_circ_clear(&state->xmit);
L
Linus Torvalds 已提交
161 162
	}

163
	retval = uport->ops->startup(uport);
L
Linus Torvalds 已提交
164
	if (retval == 0) {
165
		if (uart_console(uport) && uport->cons->cflag) {
166
			tty->termios.c_cflag = uport->cons->cflag;
167 168 169 170 171 172
			uport->cons->cflag = 0;
		}
		/*
		 * Initialise the hardware port settings.
		 */
		uart_change_speed(tty, state, NULL);
L
Linus Torvalds 已提交
173

174
		if (init_hw) {
L
Linus Torvalds 已提交
175 176 177 178
			/*
			 * Setup the RTS and DTR signals once the
			 * port is open and ready to respond.
			 */
179
			if (tty->termios.c_cflag & CBAUD)
180
				uart_set_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
L
Linus Torvalds 已提交
181
		}
182

183
		spin_lock_irq(&uport->lock);
184 185 186 187 188
		if (uart_cts_enabled(uport) &&
		    !(uport->ops->get_mctrl(uport) & TIOCM_CTS))
			uport->hw_stopped = 1;
		else
			uport->hw_stopped = 0;
189
		spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
190 191
	}

192 193 194 195 196
	/*
	 * 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 已提交
197
	if (retval && capable(CAP_SYS_ADMIN))
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222
		return 1;

	return retval;
}

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

	if (port->flags & ASYNC_INITIALIZED)
		return 0;

	/*
	 * Set the TTY IO error marker - we will only clear this
	 * once we have successfully opened the port.
	 */
	set_bit(TTY_IO_ERROR, &tty->flags);

	retval = uart_port_startup(tty, state, init_hw);
	if (!retval) {
		set_bit(ASYNCB_INITIALIZED, &port->flags);
		clear_bit(TTY_IO_ERROR, &tty->flags);
	} else if (retval > 0)
L
Linus Torvalds 已提交
223 224 225 226 227 228 229 230 231 232
		retval = 0;

	return retval;
}

/*
 * This routine will shutdown a serial port; interrupts are disabled, and
 * DTR is dropped if the hangup on close termio flag is on.  Calls to
 * uart_shutdown are serialised by the per-port semaphore.
 */
233
static void uart_shutdown(struct tty_struct *tty, struct uart_state *state)
L
Linus Torvalds 已提交
234
{
235
	struct uart_port *uport = state->uart_port;
236
	struct tty_port *port = &state->port;
L
Linus Torvalds 已提交
237 238

	/*
239
	 * Set the TTY IO error marker
L
Linus Torvalds 已提交
240
	 */
241 242
	if (tty)
		set_bit(TTY_IO_ERROR, &tty->flags);
L
Linus Torvalds 已提交
243

244
	if (test_and_clear_bit(ASYNCB_INITIALIZED, &port->flags)) {
245 246 247
		/*
		 * Turn off DTR and RTS early.
		 */
248 249 250
		if (uart_console(uport) && tty)
			uport->cons->cflag = tty->termios.c_cflag;

251
		if (!tty || (tty->termios.c_cflag & HUPCL))
252
			uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
253

J
Jiri Slaby 已提交
254
		uart_port_shutdown(port);
255
	}
L
Linus Torvalds 已提交
256 257

	/*
258 259 260
	 * 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 已提交
261
	 */
262
	clear_bit(ASYNCB_SUSPENDED, &port->flags);
L
Linus Torvalds 已提交
263 264 265 266

	/*
	 * Free the transmit buffer page.
	 */
A
Alan Cox 已提交
267 268 269
	if (state->xmit.buf) {
		free_page((unsigned long)state->xmit.buf);
		state->xmit.buf = NULL;
L
Linus Torvalds 已提交
270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300
	}
}

/**
 *	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;
301
		break; /* CS8 */
L
Linus Torvalds 已提交
302 303 304 305 306 307 308 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
	}

	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
339 340
 *	we're actually going to be using. Don't do this for the case
 *	where B0 is requested ("hang up").
L
Linus Torvalds 已提交
341 342
 */
unsigned int
A
Alan Cox 已提交
343 344
uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
		   struct ktermios *old, unsigned int min, unsigned int max)
L
Linus Torvalds 已提交
345 346
{
	unsigned int try, baud, altbaud = 38400;
347
	int hung_up = 0;
348
	upf_t flags = port->flags & UPF_SPD_MASK;
L
Linus Torvalds 已提交
349 350 351

	if (flags == UPF_SPD_HI)
		altbaud = 57600;
352
	else if (flags == UPF_SPD_VHI)
L
Linus Torvalds 已提交
353
		altbaud = 115200;
354
	else if (flags == UPF_SPD_SHI)
L
Linus Torvalds 已提交
355
		altbaud = 230400;
356
	else if (flags == UPF_SPD_WARP)
L
Linus Torvalds 已提交
357 358 359 360 361 362 363 364 365
		altbaud = 460800;

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

		/*
		 * The spd_hi, spd_vhi, spd_shi, spd_warp kludge...
		 * Die! Die! Die!
		 */
366
		if (try == 0 && baud == 38400)
L
Linus Torvalds 已提交
367 368 369 370 371
			baud = altbaud;

		/*
		 * Special case: B0 rate.
		 */
372 373
		if (baud == 0) {
			hung_up = 1;
L
Linus Torvalds 已提交
374
			baud = 9600;
375
		}
L
Linus Torvalds 已提交
376 377 378 379 380 381 382 383 384 385

		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 已提交
386
			baud = tty_termios_baud_rate(old);
387 388 389
			if (!hung_up)
				tty_termios_encode_baud_rate(termios,
								baud, baud);
L
Linus Torvalds 已提交
390 391 392 393 394
			old = NULL;
			continue;
		}

		/*
395 396
		 * As a last resort, if the range cannot be met then clip to
		 * the nearest chip supported rate.
L
Linus Torvalds 已提交
397
		 */
398 399 400 401 402 403 404 405
		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 已提交
406
	}
407 408
	/* Should never happen */
	WARN_ON(1);
L
Linus Torvalds 已提交
409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
	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
432
		quot = DIV_ROUND_CLOSEST(port->uartclk, 16 * baud);
L
Linus Torvalds 已提交
433 434 435 436 437 438

	return quot;
}

EXPORT_SYMBOL(uart_get_divisor);

439
/* Caller holds port mutex */
440 441
static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
					struct ktermios *old_termios)
L
Linus Torvalds 已提交
442
{
443
	struct uart_port *uport = state->uart_port;
A
Alan Cox 已提交
444
	struct ktermios *termios;
L
Linus Torvalds 已提交
445 446 447 448 449

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

453
	termios = &tty->termios;
454
	uport->ops->set_termios(uport, termios, old_termios);
L
Linus Torvalds 已提交
455 456

	/*
457
	 * Set modem status enables based on termios cflag
L
Linus Torvalds 已提交
458
	 */
459
	spin_lock_irq(&uport->lock);
L
Linus Torvalds 已提交
460
	if (termios->c_cflag & CRTSCTS)
461
		uport->status |= UPSTAT_CTS_ENABLE;
L
Linus Torvalds 已提交
462
	else
463
		uport->status &= ~UPSTAT_CTS_ENABLE;
L
Linus Torvalds 已提交
464 465

	if (termios->c_cflag & CLOCAL)
466
		uport->status &= ~UPSTAT_DCD_ENABLE;
L
Linus Torvalds 已提交
467
	else
468 469
		uport->status |= UPSTAT_DCD_ENABLE;
	spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
470 471
}

472 473
static inline int __uart_put_char(struct uart_port *port,
				struct circ_buf *circ, unsigned char c)
L
Linus Torvalds 已提交
474 475
{
	unsigned long flags;
476
	int ret = 0;
L
Linus Torvalds 已提交
477 478

	if (!circ->buf)
479
		return 0;
L
Linus Torvalds 已提交
480 481 482 483 484

	spin_lock_irqsave(&port->lock, flags);
	if (uart_circ_chars_free(circ) != 0) {
		circ->buf[circ->head] = c;
		circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);
485
		ret = 1;
L
Linus Torvalds 已提交
486 487
	}
	spin_unlock_irqrestore(&port->lock, flags);
488
	return ret;
L
Linus Torvalds 已提交
489 490
}

491
static int uart_put_char(struct tty_struct *tty, unsigned char ch)
L
Linus Torvalds 已提交
492 493 494
{
	struct uart_state *state = tty->driver_data;

A
Alan Cox 已提交
495
	return __uart_put_char(state->uart_port, &state->xmit, ch);
L
Linus Torvalds 已提交
496 497 498 499 500 501 502
}

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

503 504
static int uart_write(struct tty_struct *tty,
					const unsigned char *buf, int count)
L
Linus Torvalds 已提交
505 506
{
	struct uart_state *state = tty->driver_data;
507 508
	struct uart_port *port;
	struct circ_buf *circ;
L
Linus Torvalds 已提交
509 510 511
	unsigned long flags;
	int c, ret = 0;

512 513 514 515
	/*
	 * This means you called this function _after_ the port was
	 * closed.  No cookie for you.
	 */
516
	if (!state) {
517 518 519 520
		WARN_ON(1);
		return -EL3HLT;
	}

A
Alan Cox 已提交
521 522
	port = state->uart_port;
	circ = &state->xmit;
523

L
Linus Torvalds 已提交
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539
	if (!circ->buf)
		return 0;

	spin_lock_irqsave(&port->lock, flags);
	while (1) {
		c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
		if (count < c)
			c = count;
		if (c <= 0)
			break;
		memcpy(circ->buf + circ->head, buf, c);
		circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
		buf += c;
		count -= c;
		ret += c;
	}
540 541

	__uart_start(tty);
L
Linus Torvalds 已提交
542 543 544 545 546 547 548 549
	spin_unlock_irqrestore(&port->lock, flags);

	return ret;
}

static int uart_write_room(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
A
Alan Cox 已提交
550 551
	unsigned long flags;
	int ret;
L
Linus Torvalds 已提交
552

A
Alan Cox 已提交
553 554 555
	spin_lock_irqsave(&state->uart_port->lock, flags);
	ret = uart_circ_chars_free(&state->xmit);
	spin_unlock_irqrestore(&state->uart_port->lock, flags);
A
Alan Cox 已提交
556
	return ret;
L
Linus Torvalds 已提交
557 558 559 560 561
}

static int uart_chars_in_buffer(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
A
Alan Cox 已提交
562 563
	unsigned long flags;
	int ret;
L
Linus Torvalds 已提交
564

A
Alan Cox 已提交
565 566 567
	spin_lock_irqsave(&state->uart_port->lock, flags);
	ret = uart_circ_chars_pending(&state->xmit);
	spin_unlock_irqrestore(&state->uart_port->lock, flags);
A
Alan Cox 已提交
568
	return ret;
L
Linus Torvalds 已提交
569 570 571 572 573
}

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

577 578 579 580
	/*
	 * This means you called this function _after_ the port was
	 * closed.  No cookie for you.
	 */
581
	if (!state) {
582 583 584 585
		WARN_ON(1);
		return;
	}

A
Alan Cox 已提交
586
	port = state->uart_port;
J
Jiri Slaby 已提交
587
	pr_debug("uart_flush_buffer(%d) called\n", tty->index);
L
Linus Torvalds 已提交
588 589

	spin_lock_irqsave(&port->lock, flags);
A
Alan Cox 已提交
590
	uart_circ_clear(&state->xmit);
591 592
	if (port->ops->flush_buffer)
		port->ops->flush_buffer(port);
L
Linus Torvalds 已提交
593 594 595 596 597 598 599 600 601 602 603
	spin_unlock_irqrestore(&port->lock, flags);
	tty_wakeup(tty);
}

/*
 * This function is used to send a high-priority XON/XOFF character to
 * the device
 */
static void uart_send_xchar(struct tty_struct *tty, char ch)
{
	struct uart_state *state = tty->driver_data;
A
Alan Cox 已提交
604
	struct uart_port *port = state->uart_port;
L
Linus Torvalds 已提交
605 606 607 608 609
	unsigned long flags;

	if (port->ops->send_xchar)
		port->ops->send_xchar(port, ch);
	else {
P
Peter Hurley 已提交
610
		spin_lock_irqsave(&port->lock, flags);
L
Linus Torvalds 已提交
611
		port->x_char = ch;
P
Peter Hurley 已提交
612
		if (ch)
613
			port->ops->start_tx(port);
P
Peter Hurley 已提交
614
		spin_unlock_irqrestore(&port->lock, flags);
L
Linus Torvalds 已提交
615 616 617 618 619 620
	}
}

static void uart_throttle(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
621
	struct uart_port *port = state->uart_port;
622
	upf_t mask = 0;
L
Linus Torvalds 已提交
623 624

	if (I_IXOFF(tty))
625 626 627 628 629 630 631 632 633 634
		mask |= UPF_SOFT_FLOW;
	if (tty->termios.c_cflag & CRTSCTS)
		mask |= UPF_HARD_FLOW;

	if (port->flags & mask) {
		port->ops->throttle(port);
		mask &= ~port->flags;
	}

	if (mask & UPF_SOFT_FLOW)
L
Linus Torvalds 已提交
635 636
		uart_send_xchar(tty, STOP_CHAR(tty));

637 638
	if (mask & UPF_HARD_FLOW)
		uart_clear_mctrl(port, TIOCM_RTS);
L
Linus Torvalds 已提交
639 640 641 642 643
}

static void uart_unthrottle(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
A
Alan Cox 已提交
644
	struct uart_port *port = state->uart_port;
645
	upf_t mask = 0;
L
Linus Torvalds 已提交
646

647 648 649 650 651 652 653 654 655
	if (I_IXOFF(tty))
		mask |= UPF_SOFT_FLOW;
	if (tty->termios.c_cflag & CRTSCTS)
		mask |= UPF_HARD_FLOW;

	if (port->flags & mask) {
		port->ops->unthrottle(port);
		mask &= ~port->flags;
	}
L
Linus Torvalds 已提交
656

657 658
	if (mask & UPF_SOFT_FLOW)
		uart_send_xchar(tty, START_CHAR(tty));
L
Linus Torvalds 已提交
659

660
	if (mask & UPF_HARD_FLOW)
L
Linus Torvalds 已提交
661 662 663
		uart_set_mctrl(port, TIOCM_RTS);
}

A
Alan Cox 已提交
664
static void do_uart_get_info(struct tty_port *port,
665
			struct serial_struct *retinfo)
L
Linus Torvalds 已提交
666
{
A
Alan Cox 已提交
667
	struct uart_state *state = container_of(port, struct uart_state, port);
668
	struct uart_port *uport = state->uart_port;
A
Alan Cox 已提交
669

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

672 673 674
	retinfo->type	    = uport->type;
	retinfo->line	    = uport->line;
	retinfo->port	    = uport->iobase;
L
Linus Torvalds 已提交
675
	if (HIGH_BITS_OFFSET)
676 677 678 679 680 681 682
		retinfo->port_high = (long) uport->iobase >> HIGH_BITS_OFFSET;
	retinfo->irq		    = uport->irq;
	retinfo->flags	    = uport->flags;
	retinfo->xmit_fifo_size  = uport->fifosize;
	retinfo->baud_base	    = uport->uartclk / 16;
	retinfo->close_delay	    = jiffies_to_msecs(port->close_delay) / 10;
	retinfo->closing_wait    = port->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
L
Linus Torvalds 已提交
683
				ASYNC_CLOSING_WAIT_NONE :
684
				jiffies_to_msecs(port->closing_wait) / 10;
685 686 687 688 689 690 691
	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;
}

A
Alan Cox 已提交
692 693
static void uart_get_info(struct tty_port *port,
			struct serial_struct *retinfo)
694 695 696 697
{
	/* Ensure the state we copy is consistent and no hardware changes
	   occur as we go */
	mutex_lock(&port->mutex);
A
Alan Cox 已提交
698
	do_uart_get_info(port, retinfo);
699
	mutex_unlock(&port->mutex);
A
Alan Cox 已提交
700 701 702 703 704 705 706
}

static int uart_get_info_user(struct tty_port *port,
			 struct serial_struct __user *retinfo)
{
	struct serial_struct tmp;
	uart_get_info(port, &tmp);
A
Alan Cox 已提交
707

L
Linus Torvalds 已提交
708 709 710 711 712
	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
		return -EFAULT;
	return 0;
}

713 714 715
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 已提交
716
{
717
	struct uart_port *uport = state->uart_port;
L
Linus Torvalds 已提交
718
	unsigned long new_port;
719
	unsigned int change_irq, change_port, closing_wait;
L
Linus Torvalds 已提交
720
	unsigned int old_custom_divisor, close_delay;
721
	upf_t old_flags, new_flags;
L
Linus Torvalds 已提交
722 723
	int retval = 0;

724
	new_port = new_info->port;
L
Linus Torvalds 已提交
725
	if (HIGH_BITS_OFFSET)
726
		new_port += (unsigned long) new_info->port_high << HIGH_BITS_OFFSET;
L
Linus Torvalds 已提交
727

728 729 730
	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 ?
731
			ASYNC_CLOSING_WAIT_NONE :
732
			msecs_to_jiffies(new_info->closing_wait * 10);
L
Linus Torvalds 已提交
733 734


735
	change_irq  = !(uport->flags & UPF_FIXED_PORT)
736
		&& new_info->irq != uport->irq;
L
Linus Torvalds 已提交
737 738 739 740 741 742

	/*
	 * Since changing the 'type' of the port changes its resource
	 * allocations, we should treat type changes the same as
	 * IO port changes.
	 */
743 744
	change_port = !(uport->flags & UPF_FIXED_PORT)
		&& (new_port != uport->iobase ||
745 746 747 748 749
		    (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);
750 751

	old_flags = uport->flags;
752
	new_flags = new_info->flags;
753
	old_custom_divisor = uport->custom_divisor;
L
Linus Torvalds 已提交
754 755 756 757

	if (!capable(CAP_SYS_ADMIN)) {
		retval = -EPERM;
		if (change_irq || change_port ||
758
		    (new_info->baud_base != uport->uartclk / 16) ||
759 760
		    (close_delay != port->close_delay) ||
		    (closing_wait != port->closing_wait) ||
761 762
		    (new_info->xmit_fifo_size &&
		     new_info->xmit_fifo_size != uport->fifosize) ||
763
		    (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))
L
Linus Torvalds 已提交
764
			goto exit;
765
		uport->flags = ((uport->flags & ~UPF_USR_MASK) |
766
			       (new_flags & UPF_USR_MASK));
767
		uport->custom_divisor = new_info->custom_divisor;
L
Linus Torvalds 已提交
768 769 770 771 772 773
		goto check_and_exit;
	}

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

777 778
	if ((new_info->irq >= nr_irqs) || (new_info->irq < 0) ||
	    (new_info->baud_base < 9600))
L
Linus Torvalds 已提交
779 780 781 782 783 784 785 786 787 788 789
		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 已提交
790
		if (tty_port_users(port) > 1)
L
Linus Torvalds 已提交
791 792 793 794 795 796
			goto exit;

		/*
		 * We need to shutdown the serial port at the old
		 * port/type/irq combination.
		 */
797
		uart_shutdown(tty, state);
L
Linus Torvalds 已提交
798 799 800 801 802 803
	}

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

804 805 806 807 808 809
		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 已提交
810 811 812 813 814

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

817
		uport->iobase = new_port;
818 819 820 821 822
		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 已提交
823 824 825 826

		/*
		 * Claim and map the new regions
		 */
827 828
		if (uport->type != PORT_UNKNOWN) {
			retval = uport->ops->request_port(uport);
L
Linus Torvalds 已提交
829 830 831 832 833 834 835 836 837
		} else {
			/* Always success - Jean II */
			retval = 0;
		}

		/*
		 * If we fail to request resources for the
		 * new port, try to restore the old settings.
		 */
838
		if (retval) {
839 840 841 842 843 844
			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 已提交
845

846 847 848 849 850 851 852 853 854 855 856 857 858 859 860
			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;
			}

861 862
			/* Added to return the correct error -Ram Gupta */
			goto exit;
L
Linus Torvalds 已提交
863 864 865
		}
	}

866
	if (change_irq)
867
		uport->irq      = new_info->irq;
868
	if (!(uport->flags & UPF_FIXED_PORT))
869
		uport->uartclk  = new_info->baud_base * 16;
870
	uport->flags            = (uport->flags & ~UPF_CHANGE_MASK) |
871
				 (new_flags & UPF_CHANGE_MASK);
872
	uport->custom_divisor   = new_info->custom_divisor;
873 874
	port->close_delay     = close_delay;
	port->closing_wait    = closing_wait;
875 876
	if (new_info->xmit_fifo_size)
		uport->fifosize = new_info->xmit_fifo_size;
J
Jiri Slaby 已提交
877
	port->low_latency = (uport->flags & UPF_LOW_LATENCY) ? 1 : 0;
L
Linus Torvalds 已提交
878 879 880

 check_and_exit:
	retval = 0;
881
	if (uport->type == PORT_UNKNOWN)
L
Linus Torvalds 已提交
882
		goto exit;
883
	if (port->flags & ASYNC_INITIALIZED) {
884 885
		if (((old_flags ^ uport->flags) & UPF_SPD_MASK) ||
		    old_custom_divisor != uport->custom_divisor) {
L
Linus Torvalds 已提交
886 887 888 889 890
			/*
			 * If they're setting up a custom divisor or speed,
			 * instead of clearing it, then bitch about it. No
			 * need to rate-limit; it's CAP_SYS_ADMIN only.
			 */
891
			if (uport->flags & UPF_SPD_MASK) {
L
Linus Torvalds 已提交
892
				char buf[64];
893 894 895 896 897

				dev_notice(uport->dev,
				       "%s sets custom speed on %s. This is deprecated.\n",
				      current->comm,
				      tty_name(port->tty, buf));
L
Linus Torvalds 已提交
898
			}
899
			uart_change_speed(tty, state, NULL);
L
Linus Torvalds 已提交
900 901
		}
	} else
902
		retval = uart_startup(tty, state, 1);
L
Linus Torvalds 已提交
903
 exit:
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925
	return retval;
}

static int uart_set_info_user(struct tty_struct *tty, struct uart_state *state,
			 struct serial_struct __user *newinfo)
{
	struct serial_struct new_serial;
	struct tty_port *port = &state->port;
	int retval;

	if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
		return -EFAULT;

	/*
	 * This semaphore protects port->count.  It is also
	 * very useful to prevent opens.  Also, take the
	 * port configuration semaphore to make sure that a
	 * module insertion/removal doesn't change anything
	 * under us.
	 */
	mutex_lock(&port->mutex);
	retval = uart_set_info(tty, port, state, &new_serial);
926
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
927 928 929
	return retval;
}

930 931 932 933 934 935 936
/**
 *	uart_get_lsr_info	-	get line status register info
 *	@tty: tty associated with the UART
 *	@state: UART being queried
 *	@value: returned modem value
 *
 *	Note: uart_ioctl protects us against hangups.
L
Linus Torvalds 已提交
937
 */
938 939
static int uart_get_lsr_info(struct tty_struct *tty,
			struct uart_state *state, unsigned int __user *value)
L
Linus Torvalds 已提交
940
{
941
	struct uart_port *uport = state->uart_port;
L
Linus Torvalds 已提交
942 943
	unsigned int result;

944
	result = uport->ops->tx_empty(uport);
L
Linus Torvalds 已提交
945 946 947 948 949 950 951

	/*
	 * 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).
	 */
952
	if (uport->x_char ||
A
Alan Cox 已提交
953
	    ((uart_circ_chars_pending(&state->xmit) > 0) &&
954
	     !uart_tx_stopped(uport)))
L
Linus Torvalds 已提交
955
		result &= ~TIOCSER_TEMT;
956

L
Linus Torvalds 已提交
957 958 959
	return put_user(result, value);
}

960
static int uart_tiocmget(struct tty_struct *tty)
L
Linus Torvalds 已提交
961 962
{
	struct uart_state *state = tty->driver_data;
963
	struct tty_port *port = &state->port;
964
	struct uart_port *uport = state->uart_port;
L
Linus Torvalds 已提交
965 966
	int result = -EIO;

967
	mutex_lock(&port->mutex);
968
	if (!(tty->flags & (1 << TTY_IO_ERROR))) {
969 970 971 972
		result = uport->mctrl;
		spin_lock_irq(&uport->lock);
		result |= uport->ops->get_mctrl(uport);
		spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
973
	}
974
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
975 976 977 978 979

	return result;
}

static int
980
uart_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
L
Linus Torvalds 已提交
981 982
{
	struct uart_state *state = tty->driver_data;
983
	struct uart_port *uport = state->uart_port;
984
	struct tty_port *port = &state->port;
L
Linus Torvalds 已提交
985 986
	int ret = -EIO;

987
	mutex_lock(&port->mutex);
988
	if (!(tty->flags & (1 << TTY_IO_ERROR))) {
989
		uart_update_mctrl(uport, set, clear);
L
Linus Torvalds 已提交
990 991
		ret = 0;
	}
992
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
993 994 995
	return ret;
}

A
Alan Cox 已提交
996
static int uart_break_ctl(struct tty_struct *tty, int break_state)
L
Linus Torvalds 已提交
997 998
{
	struct uart_state *state = tty->driver_data;
999
	struct tty_port *port = &state->port;
1000
	struct uart_port *uport = state->uart_port;
L
Linus Torvalds 已提交
1001

1002
	mutex_lock(&port->mutex);
L
Linus Torvalds 已提交
1003

1004 1005
	if (uport->type != PORT_UNKNOWN)
		uport->ops->break_ctl(uport, break_state);
L
Linus Torvalds 已提交
1006

1007
	mutex_unlock(&port->mutex);
A
Alan Cox 已提交
1008
	return 0;
L
Linus Torvalds 已提交
1009 1010
}

1011
static int uart_do_autoconfig(struct tty_struct *tty,struct uart_state *state)
L
Linus Torvalds 已提交
1012
{
1013
	struct uart_port *uport = state->uart_port;
1014
	struct tty_port *port = &state->port;
L
Linus Torvalds 已提交
1015 1016 1017 1018 1019 1020 1021 1022 1023 1024
	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.
	 */
1025
	if (mutex_lock_interruptible(&port->mutex))
L
Linus Torvalds 已提交
1026 1027 1028
		return -ERESTARTSYS;

	ret = -EBUSY;
A
Alan Cox 已提交
1029
	if (tty_port_users(port) == 1) {
1030
		uart_shutdown(tty, state);
L
Linus Torvalds 已提交
1031 1032 1033 1034 1035

		/*
		 * If we already have a port type configured,
		 * we must release its resources.
		 */
1036 1037
		if (uport->type != PORT_UNKNOWN)
			uport->ops->release_port(uport);
L
Linus Torvalds 已提交
1038 1039

		flags = UART_CONFIG_TYPE;
1040
		if (uport->flags & UPF_AUTO_IRQ)
L
Linus Torvalds 已提交
1041 1042 1043 1044 1045 1046
			flags |= UART_CONFIG_IRQ;

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

1049
		ret = uart_startup(tty, state, 1);
L
Linus Torvalds 已提交
1050
	}
1051
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
1052 1053 1054
	return ret;
}

1055 1056 1057 1058 1059 1060 1061 1062 1063
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 已提交
1064 1065 1066 1067 1068
/*
 * 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
1069 1070 1071
 *
 * FIXME: This wants extracting into a common all driver implementation
 * of TIOCMWAIT using tty_port.
L
Linus Torvalds 已提交
1072 1073 1074 1075
 */
static int
uart_wait_modem_status(struct uart_state *state, unsigned long arg)
{
1076
	struct uart_port *uport = state->uart_port;
1077
	struct tty_port *port = &state->port;
L
Linus Torvalds 已提交
1078 1079 1080 1081 1082 1083 1084
	DECLARE_WAITQUEUE(wait, current);
	struct uart_icount cprev, cnow;
	int ret;

	/*
	 * note the counters on entry
	 */
1085 1086
	spin_lock_irq(&uport->lock);
	memcpy(&cprev, &uport->icount, sizeof(struct uart_icount));
1087
	uart_enable_ms(uport);
1088
	spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
1089

1090
	add_wait_queue(&port->delta_msr_wait, &wait);
L
Linus Torvalds 已提交
1091
	for (;;) {
1092 1093 1094
		spin_lock_irq(&uport->lock);
		memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
		spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
1095 1096 1097 1098 1099 1100 1101

		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))) {
1102 1103
			ret = 0;
			break;
L
Linus Torvalds 已提交
1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
		}

		schedule();

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

		cprev = cnow;
	}

	current->state = TASK_RUNNING;
1118
	remove_wait_queue(&port->delta_msr_wait, &wait);
L
Linus Torvalds 已提交
1119 1120 1121 1122 1123 1124 1125 1126 1127 1128

	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 已提交
1129 1130
static int uart_get_icount(struct tty_struct *tty,
			  struct serial_icounter_struct *icount)
L
Linus Torvalds 已提交
1131
{
A
Alan Cox 已提交
1132
	struct uart_state *state = tty->driver_data;
L
Linus Torvalds 已提交
1133
	struct uart_icount cnow;
1134
	struct uart_port *uport = state->uart_port;
L
Linus Torvalds 已提交
1135

1136 1137 1138
	spin_lock_irq(&uport->lock);
	memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
	spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
1139

A
Alan Cox 已提交
1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152
	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 已提交
1153 1154 1155
}

/*
1156
 * Called via sys_ioctl.  We can use spin_lock_irq() here.
L
Linus Torvalds 已提交
1157 1158
 */
static int
1159
uart_ioctl(struct tty_struct *tty, unsigned int cmd,
L
Linus Torvalds 已提交
1160 1161 1162
	   unsigned long arg)
{
	struct uart_state *state = tty->driver_data;
1163
	struct tty_port *port = &state->port;
L
Linus Torvalds 已提交
1164 1165 1166 1167 1168 1169 1170 1171 1172
	void __user *uarg = (void __user *)arg;
	int ret = -ENOIOCTLCMD;


	/*
	 * These ioctls don't rely on the hardware to be present.
	 */
	switch (cmd) {
	case TIOCGSERIAL:
A
Alan Cox 已提交
1173
		ret = uart_get_info_user(port, uarg);
L
Linus Torvalds 已提交
1174 1175 1176
		break;

	case TIOCSSERIAL:
1177
		down_write(&tty->termios_rwsem);
1178
		ret = uart_set_info_user(tty, state, uarg);
1179
		up_write(&tty->termios_rwsem);
L
Linus Torvalds 已提交
1180 1181 1182
		break;

	case TIOCSERCONFIG:
1183
		down_write(&tty->termios_rwsem);
1184
		ret = uart_do_autoconfig(tty, state);
1185
		up_write(&tty->termios_rwsem);
L
Linus Torvalds 已提交
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
		break;

	case TIOCSERGWILD: /* obsolete */
	case TIOCSERSWILD: /* obsolete */
		ret = 0;
		break;
	}

	if (ret != -ENOIOCTLCMD)
		goto out;

	if (tty->flags & (1 << TTY_IO_ERROR)) {
		ret = -EIO;
		goto out;
	}

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

	if (ret != -ENOIOCTLCMD)
		goto out;

1214
	mutex_lock(&port->mutex);
L
Linus Torvalds 已提交
1215

1216
	if (tty->flags & (1 << TTY_IO_ERROR)) {
L
Linus Torvalds 已提交
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226
		ret = -EIO;
		goto out_up;
	}

	/*
	 * All these rely on hardware being present and need to be
	 * protected against the tty being hung up.
	 */
	switch (cmd) {
	case TIOCSERGETLSR: /* Get line status register */
1227
		ret = uart_get_lsr_info(tty, state, uarg);
L
Linus Torvalds 已提交
1228 1229 1230
		break;

	default: {
1231 1232 1233
		struct uart_port *uport = state->uart_port;
		if (uport->ops->ioctl)
			ret = uport->ops->ioctl(uport, cmd, arg);
L
Linus Torvalds 已提交
1234 1235 1236
		break;
	}
	}
A
Alan Cox 已提交
1237
out_up:
1238
	mutex_unlock(&port->mutex);
A
Alan Cox 已提交
1239
out:
L
Linus Torvalds 已提交
1240 1241 1242
	return ret;
}

1243
static void uart_set_ldisc(struct tty_struct *tty)
1244 1245
{
	struct uart_state *state = tty->driver_data;
1246
	struct uart_port *uport = state->uart_port;
1247

1248 1249
	if (uport->ops->set_ldisc) {
		mutex_lock(&state->port.mutex);
1250
		uport->ops->set_ldisc(uport, &tty->termios);
1251 1252
		mutex_unlock(&state->port.mutex);
	}
1253 1254
}

1255 1256
static void uart_set_termios(struct tty_struct *tty,
						struct ktermios *old_termios)
L
Linus Torvalds 已提交
1257 1258
{
	struct uart_state *state = tty->driver_data;
1259
	struct uart_port *uport = state->uart_port;
1260
	unsigned int cflag = tty->termios.c_cflag;
1261 1262
	unsigned int iflag_mask = IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK;
	bool sw_changed = false;
L
Linus Torvalds 已提交
1263

1264 1265 1266 1267 1268 1269 1270 1271 1272 1273
	/*
	 * 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 已提交
1274 1275 1276

	/*
	 * These are the bits that are used to setup various
1277 1278 1279
	 * 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 已提交
1280 1281
	 */
	if ((cflag ^ old_termios->c_cflag) == 0 &&
1282 1283
	    tty->termios.c_ospeed == old_termios->c_ospeed &&
	    tty->termios.c_ispeed == old_termios->c_ispeed &&
1284 1285
	    ((tty->termios.c_iflag ^ old_termios->c_iflag) & iflag_mask) == 0 &&
	    !sw_changed) {
L
Linus Torvalds 已提交
1286
		return;
1287
	}
L
Linus Torvalds 已提交
1288

1289
	mutex_lock(&state->port.mutex);
1290
	uart_change_speed(tty, state, old_termios);
1291
	mutex_unlock(&state->port.mutex);
1292 1293
	/* reload cflag from termios; port driver may have overriden flags */
	cflag = tty->termios.c_cflag;
L
Linus Torvalds 已提交
1294 1295 1296

	/* Handle transition to B0 status */
	if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
1297
		uart_clear_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
L
Linus Torvalds 已提交
1298
	/* Handle transition away from B0 status */
1299
	else if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
L
Linus Torvalds 已提交
1300
		unsigned int mask = TIOCM_DTR;
P
Peter Hurley 已提交
1301
		if (!(cflag & CRTSCTS) || !test_bit(TTY_THROTTLED, &tty->flags))
L
Linus Torvalds 已提交
1302
			mask |= TIOCM_RTS;
1303
		uart_set_mctrl(uport, mask);
L
Linus Torvalds 已提交
1304 1305
	}

1306 1307
	/*
	 * If the port is doing h/w assisted flow control, do nothing.
1308
	 * We assume that port->hw_stopped has never been set.
1309 1310 1311 1312
	 */
	if (uport->flags & UPF_HARD_FLOW)
		return;

L
Linus Torvalds 已提交
1313 1314
	/* Handle turning off CRTSCTS */
	if ((old_termios->c_cflag & CRTSCTS) && !(cflag & CRTSCTS)) {
1315
		spin_lock_irq(&uport->lock);
1316
		uport->hw_stopped = 0;
L
Linus Torvalds 已提交
1317
		__uart_start(tty);
1318
		spin_unlock_irq(&uport->lock);
L
Linus Torvalds 已提交
1319
	}
1320
	/* Handle turning on CRTSCTS */
1321
	else if (!(old_termios->c_cflag & CRTSCTS) && (cflag & CRTSCTS)) {
1322
		spin_lock_irq(&uport->lock);
1323
		if (!(uport->ops->get_mctrl(uport) & TIOCM_CTS)) {
1324
			uport->hw_stopped = 1;
1325
			uport->ops->stop_tx(uport);
1326
		}
1327
		spin_unlock_irq(&uport->lock);
1328
	}
L
Linus Torvalds 已提交
1329 1330 1331
}

/*
1332 1333 1334 1335
 * Calls to uart_close() are serialised via the tty_lock in
 *   drivers/tty/tty_io.c:tty_release()
 *   drivers/tty/tty_io.c:do_tty_hangup()
 * This runs from a workqueue and can sleep for a _short_ time only.
L
Linus Torvalds 已提交
1336 1337 1338 1339
 */
static void uart_close(struct tty_struct *tty, struct file *filp)
{
	struct uart_state *state = tty->driver_data;
1340 1341
	struct tty_port *port;
	struct uart_port *uport;
1342
	unsigned long flags;
1343

1344 1345 1346 1347 1348 1349 1350 1351
	if (!state) {
		struct uart_driver *drv = tty->driver->driver_state;

		state = drv->state + tty->index;
		port = &state->port;
		spin_lock_irq(&port->lock);
		--port->count;
		spin_unlock_irq(&port->lock);
1352
		return;
1353
	}
1354

1355 1356
	uport = state->uart_port;
	port = &state->port;
L
Linus Torvalds 已提交
1357

1358
	pr_debug("uart_close(%d) called\n", uport ? uport->line : -1);
L
Linus Torvalds 已提交
1359

1360
	if (!port->count || tty_port_close_start(port, tty, filp) == 0)
1361
		return;
L
Linus Torvalds 已提交
1362 1363 1364 1365 1366

	/*
	 * At this point, we stop accepting input.  To do this, we
	 * disable the receive line status interrupts.
	 */
1367
	if (port->flags & ASYNC_INITIALIZED) {
L
Linus Torvalds 已提交
1368
		unsigned long flags;
1369
		spin_lock_irqsave(&uport->lock, flags);
1370
		uport->ops->stop_rx(uport);
1371
		spin_unlock_irqrestore(&uport->lock, flags);
L
Linus Torvalds 已提交
1372 1373 1374 1375 1376
		/*
		 * Before we drop DTR, make sure the UART transmitter
		 * has completely drained; this is especially
		 * important if there is a transmit FIFO!
		 */
1377
		uart_wait_until_sent(tty, uport->timeout);
L
Linus Torvalds 已提交
1378 1379
	}

1380
	mutex_lock(&port->mutex);
1381
	uart_shutdown(tty, state);
A
Alan Cox 已提交
1382
	tty_port_tty_set(port, NULL);
1383
	tty->closing = 0;
1384
	spin_lock_irqsave(&port->lock, flags);
L
Linus Torvalds 已提交
1385

1386
	if (port->blocked_open) {
1387
		spin_unlock_irqrestore(&port->lock, flags);
1388
		if (port->close_delay)
1389
			msleep_interruptible(jiffies_to_msecs(port->close_delay));
1390
		spin_lock_irqsave(&port->lock, flags);
1391
	} else if (!uart_console(uport)) {
1392
		spin_unlock_irqrestore(&port->lock, flags);
1393
		uart_change_pm(state, UART_PM_STATE_OFF);
1394
		spin_lock_irqsave(&port->lock, flags);
L
Linus Torvalds 已提交
1395 1396 1397 1398 1399
	}

	/*
	 * Wake up anyone trying to open this port.
	 */
1400
	clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
1401
	clear_bit(ASYNCB_CLOSING, &port->flags);
1402
	spin_unlock_irqrestore(&port->lock, flags);
1403
	wake_up_interruptible(&port->open_wait);
1404
	wake_up_interruptible(&port->close_wait);
L
Linus Torvalds 已提交
1405

1406
	mutex_unlock(&port->mutex);
1407 1408

	tty_ldisc_flush(tty);
L
Linus Torvalds 已提交
1409 1410
}

1411
static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
L
Linus Torvalds 已提交
1412
{
1413 1414
	struct uart_state *state = tty->driver_data;
	struct uart_port *port = state->uart_port;
L
Linus Torvalds 已提交
1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
	unsigned long char_time, expire;

	if (port->type == PORT_UNKNOWN || port->fifosize == 0)
		return;

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

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

	expire = jiffies + timeout;

J
Jiri Slaby 已提交
1449
	pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n",
1450
		port->line, jiffies, expire);
L
Linus Torvalds 已提交
1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463

	/*
	 * 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;
	}
1464 1465
}

L
Linus Torvalds 已提交
1466
/*
1467 1468 1469
 * 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 已提交
1470 1471 1472 1473
 */
static void uart_hangup(struct tty_struct *tty)
{
	struct uart_state *state = tty->driver_data;
1474
	struct tty_port *port = &state->port;
1475
	unsigned long flags;
L
Linus Torvalds 已提交
1476

A
Alan Cox 已提交
1477
	pr_debug("uart_hangup(%d)\n", state->uart_port->line);
L
Linus Torvalds 已提交
1478

1479
	mutex_lock(&port->mutex);
1480
	if (port->flags & ASYNC_NORMAL_ACTIVE) {
L
Linus Torvalds 已提交
1481
		uart_flush_buffer(tty);
1482
		uart_shutdown(tty, state);
1483
		spin_lock_irqsave(&port->lock, flags);
1484
		port->count = 0;
1485
		clear_bit(ASYNCB_NORMAL_ACTIVE, &port->flags);
1486
		spin_unlock_irqrestore(&port->lock, flags);
A
Alan Cox 已提交
1487
		tty_port_tty_set(port, NULL);
1488 1489
		if (!uart_console(state->uart_port))
			uart_change_pm(state, UART_PM_STATE_OFF);
1490
		wake_up_interruptible(&port->open_wait);
1491
		wake_up_interruptible(&port->delta_msr_wait);
L
Linus Torvalds 已提交
1492
	}
1493
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
1494 1495
}

1496 1497 1498 1499 1500 1501 1502
static int uart_port_activate(struct tty_port *port, struct tty_struct *tty)
{
	return 0;
}

static void uart_port_shutdown(struct tty_port *port)
{
J
Jiri Slaby 已提交
1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523
	struct uart_state *state = container_of(port, struct uart_state, port);
	struct uart_port *uport = state->uart_port;

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

	/*
	 * Free the IRQ and disable the port.
	 */
	uport->ops->shutdown(uport);

	/*
	 * Ensure that the IRQ handler isn't running on another CPU.
	 */
	synchronize_irq(uport->irq);
1524 1525
}

A
Alan Cox 已提交
1526 1527 1528 1529 1530 1531
static int uart_carrier_raised(struct tty_port *port)
{
	struct uart_state *state = container_of(port, struct uart_state, port);
	struct uart_port *uport = state->uart_port;
	int mctrl;
	spin_lock_irq(&uport->lock);
1532
	uart_enable_ms(uport);
A
Alan Cox 已提交
1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543
	mctrl = uport->ops->get_mctrl(uport);
	spin_unlock_irq(&uport->lock);
	if (mctrl & TIOCM_CAR)
		return 1;
	return 0;
}

static void uart_dtr_rts(struct tty_port *port, int onoff)
{
	struct uart_state *state = container_of(port, struct uart_state, port);
	struct uart_port *uport = state->uart_port;
A
Alan Cox 已提交
1544

1545
	if (onoff)
A
Alan Cox 已提交
1546 1547 1548 1549 1550
		uart_set_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
	else
		uart_clear_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
}

L
Linus Torvalds 已提交
1551
/*
1552 1553
 * Calls to uart_open are serialised by the tty_lock in
 *   drivers/tty/tty_io.c:tty_open()
L
Linus Torvalds 已提交
1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
 * Note that if this fails, then uart_close() _will_ be called.
 *
 * In time, we want to scrap the "opening nonpresent ports"
 * behaviour and implement an alternative way for setserial
 * to set base addresses/ports/types.  This will allow us to
 * get rid of a certain amount of extra tests.
 */
static int uart_open(struct tty_struct *tty, struct file *filp)
{
	struct uart_driver *drv = (struct uart_driver *)tty->driver->driver_state;
	int retval, line = tty->index;
J
Jiri Slaby 已提交
1565 1566
	struct uart_state *state = drv->state + line;
	struct tty_port *port = &state->port;
L
Linus Torvalds 已提交
1567

J
Jiri Slaby 已提交
1568
	pr_debug("uart_open(%d) called\n", line);
L
Linus Torvalds 已提交
1569

1570 1571 1572 1573
	spin_lock_irq(&port->lock);
	++port->count;
	spin_unlock_irq(&port->lock);

L
Linus Torvalds 已提交
1574
	/*
J
Jiri Slaby 已提交
1575 1576 1577 1578 1579
	 * We take the semaphore here to guarantee that we won't be re-entered
	 * while allocating the state structure, or while we request any IRQs
	 * that the driver may need.  This also has the nice side-effect that
	 * it delays the action of uart_hangup, so we can guarantee that
	 * state->port.tty will always contain something reasonable.
L
Linus Torvalds 已提交
1580
	 */
J
Jiri Slaby 已提交
1581 1582 1583 1584 1585 1586 1587
	if (mutex_lock_interruptible(&port->mutex)) {
		retval = -ERESTARTSYS;
		goto end;
	}

	if (!state->uart_port || state->uart_port->flags & UPF_DEAD) {
		retval = -ENXIO;
1588
		goto err_unlock;
L
Linus Torvalds 已提交
1589 1590 1591
	}

	tty->driver_data = state;
A
Alan Cox 已提交
1592
	state->uart_port->state = state;
J
Jiri Slaby 已提交
1593 1594
	state->port.low_latency =
		(state->uart_port->flags & UPF_LOW_LATENCY) ? 1 : 0;
A
Alan Cox 已提交
1595
	tty_port_tty_set(port, tty);
L
Linus Torvalds 已提交
1596 1597 1598 1599

	/*
	 * Start up the serial port.
	 */
1600
	retval = uart_startup(tty, state, 0);
L
Linus Torvalds 已提交
1601 1602 1603 1604

	/*
	 * If we succeeded, wait until the port is ready.
	 */
1605
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
1606
	if (retval == 0)
A
Alan Cox 已提交
1607
		retval = tty_port_block_til_ready(port, tty, filp);
L
Linus Torvalds 已提交
1608

J
Jiri Slaby 已提交
1609
end:
L
Linus Torvalds 已提交
1610
	return retval;
1611
err_unlock:
J
Jiri Slaby 已提交
1612 1613
	mutex_unlock(&port->mutex);
	goto end;
L
Linus Torvalds 已提交
1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
}

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

1631
static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i)
L
Linus Torvalds 已提交
1632 1633
{
	struct uart_state *state = drv->state + i;
1634
	struct tty_port *port = &state->port;
1635
	enum uart_pm_state pm_state;
1636
	struct uart_port *uport = state->uart_port;
L
Linus Torvalds 已提交
1637 1638
	char stat_buf[32];
	unsigned int status;
1639
	int mmio;
L
Linus Torvalds 已提交
1640

1641
	if (!uport)
1642
		return;
L
Linus Torvalds 已提交
1643

1644
	mmio = uport->iotype >= UPIO_MEM;
1645
	seq_printf(m, "%d: uart:%s %s%08llX irq:%d",
1646
			uport->line, uart_type(uport),
1647
			mmio ? "mmio:0x" : "port:",
1648 1649 1650
			mmio ? (unsigned long long)uport->mapbase
			     : (unsigned long long)uport->iobase,
			uport->irq);
L
Linus Torvalds 已提交
1651

1652
	if (uport->type == PORT_UNKNOWN) {
1653 1654
		seq_putc(m, '\n');
		return;
L
Linus Torvalds 已提交
1655 1656
	}

1657
	if (capable(CAP_SYS_ADMIN)) {
1658
		mutex_lock(&port->mutex);
1659
		pm_state = state->pm_state;
1660 1661
		if (pm_state != UART_PM_STATE_ON)
			uart_change_pm(state, UART_PM_STATE_ON);
1662 1663 1664
		spin_lock_irq(&uport->lock);
		status = uport->ops->get_mctrl(uport);
		spin_unlock_irq(&uport->lock);
1665
		if (pm_state != UART_PM_STATE_ON)
1666
			uart_change_pm(state, pm_state);
1667
		mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
1668

1669
		seq_printf(m, " tx:%d rx:%d",
1670 1671
				uport->icount.tx, uport->icount.rx);
		if (uport->icount.frame)
1672
			seq_printf(m, " fe:%d",
1673 1674
				uport->icount.frame);
		if (uport->icount.parity)
1675
			seq_printf(m, " pe:%d",
1676 1677
				uport->icount.parity);
		if (uport->icount.brk)
1678
			seq_printf(m, " brk:%d",
1679 1680
				uport->icount.brk);
		if (uport->icount.overrun)
1681
			seq_printf(m, " oe:%d",
1682
				uport->icount.overrun);
1683 1684

#define INFOBIT(bit, str) \
1685
	if (uport->mctrl & (bit)) \
L
Linus Torvalds 已提交
1686 1687
		strncat(stat_buf, (str), sizeof(stat_buf) - \
			strlen(stat_buf) - 2)
1688
#define STATBIT(bit, str) \
L
Linus Torvalds 已提交
1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702
	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] = ' ';
1703

1704
		seq_puts(m, stat_buf);
L
Linus Torvalds 已提交
1705
	}
1706
	seq_putc(m, '\n');
L
Linus Torvalds 已提交
1707 1708 1709 1710
#undef STATBIT
#undef INFOBIT
}

1711
static int uart_proc_show(struct seq_file *m, void *v)
L
Linus Torvalds 已提交
1712
{
1713
	struct tty_driver *ttydrv = m->private;
L
Linus Torvalds 已提交
1714
	struct uart_driver *drv = ttydrv->driver_state;
1715
	int i;
L
Linus Torvalds 已提交
1716

1717
	seq_printf(m, "serinfo:1.0 driver%s%s revision:%s\n",
L
Linus Torvalds 已提交
1718
			"", "", "");
1719 1720 1721
	for (i = 0; i < drv->nr; i++)
		uart_line_info(m, drv, i);
	return 0;
L
Linus Torvalds 已提交
1722
}
1723 1724 1725

static int uart_proc_open(struct inode *inode, struct file *file)
{
A
Al Viro 已提交
1726
	return single_open(file, uart_proc_show, PDE_DATA(inode));
1727 1728 1729 1730 1731 1732 1733 1734 1735
}

static const struct file_operations uart_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= uart_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};
L
Linus Torvalds 已提交
1736 1737
#endif

A
Andrew Morton 已提交
1738
#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(CONFIG_CONSOLE_POLL)
1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
/*
 *	uart_console_write - write a console message to a serial port
 *	@port: the port to write the message
 *	@s: array of characters
 *	@count: number of characters in string to write
 *	@write: function to write character to port
 */
void uart_console_write(struct uart_port *port, const char *s,
			unsigned int count,
			void (*putchar)(struct uart_port *, int))
{
	unsigned int i;

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

L
Linus Torvalds 已提交
1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
/*
 *	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;
}

/**
1783
 *	uart_parse_options - Parse serial port baud/parity/bits/flow control.
L
Linus Torvalds 已提交
1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
 *	@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 已提交
1794
void
L
Linus Torvalds 已提交
1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808
uart_parse_options(char *options, int *baud, int *parity, int *bits, int *flow)
{
	char *s = options;

	*baud = simple_strtoul(s, NULL, 10);
	while (*s >= '0' && *s <= '9')
		s++;
	if (*s)
		*parity = *s++;
	if (*s)
		*bits = *s++ - '0';
	if (*s)
		*flow = *s;
}
J
Jason Wessel 已提交
1809
EXPORT_SYMBOL_GPL(uart_parse_options);
L
Linus Torvalds 已提交
1810 1811 1812 1813 1814 1815

struct baud_rates {
	unsigned int rate;
	unsigned int cflag;
};

1816
static const struct baud_rates baud_rates[] = {
L
Linus Torvalds 已提交
1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839
	{ 921600, B921600 },
	{ 460800, B460800 },
	{ 230400, B230400 },
	{ 115200, B115200 },
	{  57600, B57600  },
	{  38400, B38400  },
	{  19200, B19200  },
	{   9600, B9600   },
	{   4800, B4800   },
	{   2400, B2400   },
	{   1200, B1200   },
	{      0, B38400  }
};

/**
 *	uart_set_options - setup the serial console parameters
 *	@port: pointer to the serial ports uart_port structure
 *	@co: console pointer
 *	@baud: baud rate
 *	@parity: parity character - 'n' (none), 'o' (odd), 'e' (even)
 *	@bits: number of data bits
 *	@flow: flow control character - 'r' (rts)
 */
J
Jason Wessel 已提交
1840
int
L
Linus Torvalds 已提交
1841 1842 1843
uart_set_options(struct uart_port *port, struct console *co,
		 int baud, int parity, int bits, int flow)
{
A
Alan Cox 已提交
1844
	struct ktermios termios;
1845
	static struct ktermios dummy;
L
Linus Torvalds 已提交
1846 1847
	int i;

1848 1849 1850
	/*
	 * Ensure that the serial console lock is initialised
	 * early.
1851 1852
	 * If this port is a console, then the spinlock is already
	 * initialised.
1853
	 */
1854 1855 1856 1857
	if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) {
		spin_lock_init(&port->lock);
		lockdep_set_class(&port->lock, &port_lock_key);
	}
1858

A
Alan Cox 已提交
1859
	memset(&termios, 0, sizeof(struct ktermios));
L
Linus Torvalds 已提交
1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888

	termios.c_cflag = CREAD | HUPCL | CLOCAL;

	/*
	 * Construct a cflag setting.
	 */
	for (i = 0; baud_rates[i].rate; i++)
		if (baud_rates[i].rate <= baud)
			break;

	termios.c_cflag |= baud_rates[i].cflag;

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

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

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

1889 1890 1891 1892 1893 1894
	/*
	 * 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;

1895
	port->ops->set_termios(port, &termios, &dummy);
J
Jason Wessel 已提交
1896 1897 1898 1899 1900 1901
	/*
	 * Allow the setting of the UART parameters with a NULL console
	 * too:
	 */
	if (co)
		co->cflag = termios.c_cflag;
L
Linus Torvalds 已提交
1902 1903 1904

	return 0;
}
J
Jason Wessel 已提交
1905
EXPORT_SYMBOL_GPL(uart_set_options);
L
Linus Torvalds 已提交
1906 1907
#endif /* CONFIG_SERIAL_CORE_CONSOLE */

J
Jiri Slaby 已提交
1908 1909 1910 1911 1912 1913 1914 1915
/**
 * uart_change_pm - set power state of the port
 *
 * @state: port descriptor
 * @pm_state: new state
 *
 * Locking: port->mutex has to be held
 */
1916 1917
static void uart_change_pm(struct uart_state *state,
			   enum uart_pm_state pm_state)
L
Linus Torvalds 已提交
1918
{
A
Alan Cox 已提交
1919
	struct uart_port *port = state->uart_port;
1920 1921 1922 1923 1924 1925

	if (state->pm_state != pm_state) {
		if (port->ops->pm)
			port->ops->pm(port, pm_state, state->pm_state);
		state->pm_state = pm_state;
	}
L
Linus Torvalds 已提交
1926 1927
}

G
Guennadi Liakhovetski 已提交
1928 1929 1930 1931 1932 1933 1934 1935
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;
1936 1937 1938
	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 已提交
1939 1940 1941 1942

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

1943
int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
L
Linus Torvalds 已提交
1944
{
1945 1946
	struct uart_state *state = drv->state + uport->line;
	struct tty_port *port = &state->port;
G
Guennadi Liakhovetski 已提交
1947
	struct device *tty_dev;
1948
	struct uart_match match = {uport, drv};
L
Linus Torvalds 已提交
1949

1950
	mutex_lock(&port->mutex);
L
Linus Torvalds 已提交
1951

1952
	tty_dev = device_find_child(uport->dev, &match, serial_match_port);
G
Guennadi Liakhovetski 已提交
1953
	if (device_may_wakeup(tty_dev)) {
1954 1955
		if (!enable_irq_wake(uport->irq))
			uport->irq_wake = 1;
G
Guennadi Liakhovetski 已提交
1956
		put_device(tty_dev);
1957
		mutex_unlock(&port->mutex);
G
Guennadi Liakhovetski 已提交
1958 1959
		return 0;
	}
1960 1961
	put_device(tty_dev);

1962 1963
	if (console_suspend_enabled || !uart_console(uport))
		uport->suspended = 1;
G
Guennadi Liakhovetski 已提交
1964

1965 1966
	if (port->flags & ASYNC_INITIALIZED) {
		const struct uart_ops *ops = uport->ops;
1967
		int tries;
L
Linus Torvalds 已提交
1968

1969 1970 1971
		if (console_suspend_enabled || !uart_console(uport)) {
			set_bit(ASYNCB_SUSPENDED, &port->flags);
			clear_bit(ASYNCB_INITIALIZED, &port->flags);
1972

1973 1974 1975 1976 1977 1978
			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 已提交
1979 1980 1981 1982

		/*
		 * Wait for the transmitter to empty.
		 */
1983
		for (tries = 3; !ops->tx_empty(uport) && tries; tries--)
L
Linus Torvalds 已提交
1984
			msleep(10);
1985
		if (!tries)
1986 1987 1988
			dev_err(uport->dev, "%s%d: Unable to drain transmitter\n",
				drv->dev_name,
				drv->tty_driver->name_base + uport->line);
L
Linus Torvalds 已提交
1989

1990 1991
		if (console_suspend_enabled || !uart_console(uport))
			ops->shutdown(uport);
L
Linus Torvalds 已提交
1992 1993 1994 1995 1996
	}

	/*
	 * Disable the console device before suspending.
	 */
1997
	if (console_suspend_enabled && uart_console(uport))
1998
		console_stop(uport->cons);
L
Linus Torvalds 已提交
1999

2000
	if (console_suspend_enabled || !uart_console(uport))
2001
		uart_change_pm(state, UART_PM_STATE_OFF);
L
Linus Torvalds 已提交
2002

2003
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
2004 2005 2006 2007

	return 0;
}

2008
int uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
L
Linus Torvalds 已提交
2009
{
2010 2011
	struct uart_state *state = drv->state + uport->line;
	struct tty_port *port = &state->port;
2012
	struct device *tty_dev;
2013
	struct uart_match match = {uport, drv};
2014
	struct ktermios termios;
L
Linus Torvalds 已提交
2015

2016
	mutex_lock(&port->mutex);
L
Linus Torvalds 已提交
2017

2018 2019
	tty_dev = device_find_child(uport->dev, &match, serial_match_port);
	if (!uport->suspended && device_may_wakeup(tty_dev)) {
2020 2021 2022 2023
		if (uport->irq_wake) {
			disable_irq_wake(uport->irq);
			uport->irq_wake = 0;
		}
2024
		put_device(tty_dev);
2025
		mutex_unlock(&port->mutex);
G
Guennadi Liakhovetski 已提交
2026 2027
		return 0;
	}
2028
	put_device(tty_dev);
2029
	uport->suspended = 0;
G
Guennadi Liakhovetski 已提交
2030

L
Linus Torvalds 已提交
2031 2032 2033
	/*
	 * Re-enable the console device after suspending.
	 */
2034
	if (uart_console(uport)) {
2035 2036 2037 2038 2039 2040 2041 2042 2043
		/*
		 * 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.
		 */
2044 2045
		if (port->tty && termios.c_cflag == 0)
			termios = port->tty->termios;
2046

2047
		if (console_suspend_enabled)
2048
			uart_change_pm(state, UART_PM_STATE_ON);
2049
		uport->ops->set_termios(uport, &termios, NULL);
2050 2051
		if (console_suspend_enabled)
			console_start(uport->cons);
L
Linus Torvalds 已提交
2052 2053
	}

2054 2055
	if (port->flags & ASYNC_SUSPENDED) {
		const struct uart_ops *ops = uport->ops;
2056
		int ret;
L
Linus Torvalds 已提交
2057

2058
		uart_change_pm(state, UART_PM_STATE_ON);
2059 2060 2061
		spin_lock_irq(&uport->lock);
		ops->set_mctrl(uport, 0);
		spin_unlock_irq(&uport->lock);
2062
		if (console_suspend_enabled || !uart_console(uport)) {
2063 2064
			/* Protected by port mutex for now */
			struct tty_struct *tty = port->tty;
2065 2066
			ret = ops->startup(uport);
			if (ret == 0) {
2067 2068
				if (tty)
					uart_change_speed(tty, state, NULL);
2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079
				spin_lock_irq(&uport->lock);
				ops->set_mctrl(uport, uport->mctrl);
				ops->start_tx(uport);
				spin_unlock_irq(&uport->lock);
				set_bit(ASYNCB_INITIALIZED, &port->flags);
			} else {
				/*
				 * Failed to resume - maybe hardware went away?
				 * Clear the "initialized" flag so we won't try
				 * to call the low level drivers shutdown method.
				 */
2080
				uart_shutdown(tty, state);
2081
			}
2082
		}
2083

2084
		clear_bit(ASYNCB_SUSPENDED, &port->flags);
L
Linus Torvalds 已提交
2085 2086
	}

2087
	mutex_unlock(&port->mutex);
L
Linus Torvalds 已提交
2088 2089 2090 2091 2092 2093 2094

	return 0;
}

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

L
Linus Torvalds 已提交
2097 2098
	switch (port->iotype) {
	case UPIO_PORT:
2099
		snprintf(address, sizeof(address), "I/O 0x%lx", port->iobase);
L
Linus Torvalds 已提交
2100 2101
		break;
	case UPIO_HUB6:
2102
		snprintf(address, sizeof(address),
2103
			 "I/O 0x%lx offset 0x%x", port->iobase, port->hub6);
L
Linus Torvalds 已提交
2104 2105 2106
		break;
	case UPIO_MEM:
	case UPIO_MEM32:
2107
	case UPIO_AU:
2108
	case UPIO_TSI:
2109
		snprintf(address, sizeof(address),
2110
			 "MMIO 0x%llx", (unsigned long long)port->mapbase);
2111 2112 2113
		break;
	default:
		strlcpy(address, "*unknown*", sizeof(address));
L
Linus Torvalds 已提交
2114 2115
		break;
	}
2116

2117
	dev_info(port->dev, "%s%d at %s (irq = %d, base_baud = %d) is a %s\n",
2118 2119
	       drv->dev_name,
	       drv->tty_driver->name_base + port->line,
2120
	       address, port->irq, port->uartclk / 16, uart_type(port));
L
Linus Torvalds 已提交
2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138
}

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.
	 */
2139
	flags = 0;
L
Linus Torvalds 已提交
2140 2141 2142
	if (port->flags & UPF_AUTO_IRQ)
		flags |= UART_CONFIG_IRQ;
	if (port->flags & UPF_BOOT_AUTOCONF) {
2143 2144 2145 2146
		if (!(port->flags & UPF_FIXED_TYPE)) {
			port->type = PORT_UNKNOWN;
			flags |= UART_CONFIG_TYPE;
		}
L
Linus Torvalds 已提交
2147 2148 2149 2150 2151 2152 2153 2154
		port->ops->config_port(port, flags);
	}

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

		uart_report_port(drv, port);

2155
		/* Power up port for set_mctrl() */
2156
		uart_change_pm(state, UART_PM_STATE_ON);
2157

L
Linus Torvalds 已提交
2158 2159
		/*
		 * Ensure that the modem control lines are de-activated.
2160
		 * keep the DTR setting that is set in uart_set_options()
L
Linus Torvalds 已提交
2161 2162 2163
		 * We probably don't need a spinlock around this, but
		 */
		spin_lock_irqsave(&port->lock, flags);
2164
		port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR);
L
Linus Torvalds 已提交
2165 2166
		spin_unlock_irqrestore(&port->lock, flags);

2167 2168 2169 2170 2171 2172 2173 2174
		/*
		 * 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 已提交
2175 2176 2177 2178 2179
		/*
		 * Power down all ports by default, except the
		 * console if we have one.
		 */
		if (!uart_console(port))
2180
			uart_change_pm(state, UART_PM_STATE_OFF);
L
Linus Torvalds 已提交
2181 2182 2183
	}
}

J
Jason Wessel 已提交
2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194
#ifdef CONFIG_CONSOLE_POLL

static int uart_poll_init(struct tty_driver *driver, int line, char *options)
{
	struct uart_driver *drv = driver->driver_state;
	struct uart_state *state = drv->state + line;
	struct uart_port *port;
	int baud = 9600;
	int bits = 8;
	int parity = 'n';
	int flow = 'n';
2195
	int ret;
J
Jason Wessel 已提交
2196

A
Alan Cox 已提交
2197
	if (!state || !state->uart_port)
J
Jason Wessel 已提交
2198 2199
		return -1;

A
Alan Cox 已提交
2200
	port = state->uart_port;
J
Jason Wessel 已提交
2201 2202 2203
	if (!(port->ops->poll_get_char && port->ops->poll_put_char))
		return -1;

2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219
	if (port->ops->poll_init) {
		struct tty_port *tport = &state->port;

		ret = 0;
		mutex_lock(&tport->mutex);
		/*
		 * We don't set ASYNCB_INITIALIZED as we only initialized the
		 * hw, e.g. state->xmit is still uninitialized.
		 */
		if (!test_bit(ASYNCB_INITIALIZED, &tport->flags))
			ret = port->ops->poll_init(port);
		mutex_unlock(&tport->mutex);
		if (ret)
			return ret;
	}

J
Jason Wessel 已提交
2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233
	if (options) {
		uart_parse_options(options, &baud, &parity, &bits, &flow);
		return uart_set_options(port, NULL, baud, parity, bits, flow);
	}

	return 0;
}

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

A
Alan Cox 已提交
2234
	if (!state || !state->uart_port)
J
Jason Wessel 已提交
2235 2236
		return -1;

A
Alan Cox 已提交
2237
	port = state->uart_port;
J
Jason Wessel 已提交
2238 2239 2240 2241 2242 2243 2244 2245 2246
	return port->ops->poll_get_char(port);
}

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

A
Alan Cox 已提交
2247
	if (!state || !state->uart_port)
J
Jason Wessel 已提交
2248 2249
		return;

A
Alan Cox 已提交
2250
	port = state->uart_port;
2251 2252 2253

	if (ch == '\n')
		port->ops->poll_put_char(port, '\r');
J
Jason Wessel 已提交
2254 2255 2256 2257
	port->ops->poll_put_char(port, ch);
}
#endif

J
Jeff Dike 已提交
2258
static const struct tty_operations uart_ops = {
L
Linus Torvalds 已提交
2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271
	.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,
2272
	.set_ldisc	= uart_set_ldisc,
L
Linus Torvalds 已提交
2273 2274 2275 2276 2277 2278
	.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
2279
	.proc_fops	= &uart_proc_fops,
L
Linus Torvalds 已提交
2280 2281 2282
#endif
	.tiocmget	= uart_tiocmget,
	.tiocmset	= uart_tiocmset,
A
Alan Cox 已提交
2283
	.get_icount	= uart_get_icount,
J
Jason Wessel 已提交
2284 2285 2286 2287 2288
#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 已提交
2289 2290
};

A
Alan Cox 已提交
2291
static const struct tty_port_operations uart_port_ops = {
2292 2293
	.activate	= uart_port_activate,
	.shutdown	= uart_port_shutdown,
A
Alan Cox 已提交
2294 2295 2296 2297
	.carrier_raised = uart_carrier_raised,
	.dtr_rts	= uart_dtr_rts,
};

L
Linus Torvalds 已提交
2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312
/**
 *	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)
{
2313
	struct tty_driver *normal;
L
Linus Torvalds 已提交
2314 2315 2316 2317 2318 2319 2320 2321
	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.
	 */
2322
	drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
L
Linus Torvalds 已提交
2323 2324 2325
	if (!drv->state)
		goto out;

2326
	normal = alloc_tty_driver(drv->nr);
L
Linus Torvalds 已提交
2327
	if (!normal)
2328
		goto out_kfree;
L
Linus Torvalds 已提交
2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339

	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 已提交
2340
	normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
2341
	normal->flags		= TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
L
Linus Torvalds 已提交
2342 2343 2344 2345 2346 2347 2348 2349
	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;
2350
		struct tty_port *port = &state->port;
L
Linus Torvalds 已提交
2351

2352
		tty_port_init(port);
A
Alan Cox 已提交
2353
		port->ops = &uart_port_ops;
L
Linus Torvalds 已提交
2354 2355 2356
	}

	retval = tty_register_driver(normal);
2357 2358 2359
	if (retval >= 0)
		return retval;

2360 2361
	for (i = 0; i < drv->nr; i++)
		tty_port_destroy(&drv->state[i].port);
2362 2363 2364 2365 2366
	put_tty_driver(normal);
out_kfree:
	kfree(drv->state);
out:
	return -ENOMEM;
L
Linus Torvalds 已提交
2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380
}

/**
 *	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;
2381 2382
	unsigned int i;

L
Linus Torvalds 已提交
2383 2384
	tty_unregister_driver(p);
	put_tty_driver(p);
2385 2386
	for (i = 0; i < drv->nr; i++)
		tty_port_destroy(&drv->state[i].port);
L
Linus Torvalds 已提交
2387
	kfree(drv->state);
2388
	drv->state = NULL;
L
Linus Torvalds 已提交
2389 2390 2391 2392 2393 2394 2395 2396 2397 2398
	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;
}

2399 2400 2401
static ssize_t uart_get_attr_uartclk(struct device *dev,
	struct device_attribute *attr, char *buf)
{
2402
	struct serial_struct tmp;
2403 2404
	struct tty_port *port = dev_get_drvdata(dev);

A
Alan Cox 已提交
2405
	uart_get_info(port, &tmp);
2406
	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.baud_base * 16);
2407 2408
}

2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432
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);
2433
	unsigned long ioaddr;
2434 2435

	uart_get_info(port, &tmp);
2436 2437 2438 2439
	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);
2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539
}

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);
2540
static DEVICE_ATTR(uartclk, S_IRUSR | S_IRGRP, uart_get_attr_uartclk, NULL);
2541 2542 2543 2544 2545 2546
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);
2547 2548

static struct attribute *tty_dev_attrs[] = {
2549 2550 2551 2552 2553 2554
	&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,
2555
	&dev_attr_uartclk.attr,
2556 2557 2558 2559 2560 2561
	&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,
2562 2563 2564
	NULL,
	};

2565
static const struct attribute_group tty_dev_attr_group = {
2566 2567 2568
	.attrs = tty_dev_attrs,
	};

L
Linus Torvalds 已提交
2569 2570 2571
/**
 *	uart_add_one_port - attach a driver-defined port structure
 *	@drv: pointer to the uart low level driver structure for this port
2572
 *	@uport: uart port structure to use for this port.
L
Linus Torvalds 已提交
2573 2574 2575 2576 2577 2578
 *
 *	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.
 */
2579
int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
L
Linus Torvalds 已提交
2580 2581
{
	struct uart_state *state;
2582
	struct tty_port *port;
L
Linus Torvalds 已提交
2583
	int ret = 0;
G
Guennadi Liakhovetski 已提交
2584
	struct device *tty_dev;
2585
	int num_groups;
L
Linus Torvalds 已提交
2586 2587 2588

	BUG_ON(in_interrupt());

2589
	if (uport->line >= drv->nr)
L
Linus Torvalds 已提交
2590 2591
		return -EINVAL;

2592 2593
	state = drv->state + uport->line;
	port = &state->port;
L
Linus Torvalds 已提交
2594

2595
	mutex_lock(&port_mutex);
2596
	mutex_lock(&port->mutex);
A
Alan Cox 已提交
2597
	if (state->uart_port) {
L
Linus Torvalds 已提交
2598 2599 2600 2601
		ret = -EINVAL;
		goto out;
	}

2602
	/* Link the port to the driver state table and vice versa */
2603
	state->uart_port = uport;
2604
	uport->state = state;
L
Linus Torvalds 已提交
2605

2606
	state->pm_state = UART_PM_STATE_UNDEFINED;
2607
	uport->cons = drv->cons;
L
Linus Torvalds 已提交
2608

2609 2610 2611 2612
	/*
	 * If this port is a console, then the spinlock is already
	 * initialised.
	 */
2613 2614 2615
	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 已提交
2616
	}
2617 2618
	if (uport->cons && uport->dev)
		of_console_check(uport->dev->of_node, uport->cons->name, uport->line);
2619

2620
	uart_configure_port(drv, state, uport);
L
Linus Torvalds 已提交
2621

2622 2623 2624 2625
	num_groups = 2;
	if (uport->attr_group)
		num_groups++;

2626
	uport->tty_groups = kcalloc(num_groups, sizeof(*uport->tty_groups),
2627 2628 2629 2630 2631 2632 2633 2634 2635
				    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 已提交
2636 2637
	/*
	 * Register the port whether it's detected or not.  This allows
2638
	 * setserial to be used to alter this port's parameters.
L
Linus Torvalds 已提交
2639
	 */
2640
	tty_dev = tty_port_register_device_attr(port, drv->tty_driver,
2641
			uport->line, uport->dev, port, uport->tty_groups);
G
Guennadi Liakhovetski 已提交
2642
	if (likely(!IS_ERR(tty_dev))) {
2643 2644
		device_set_wakeup_capable(tty_dev, 1);
	} else {
2645
		dev_err(uport->dev, "Cannot register tty device on line %d\n",
2646
		       uport->line);
2647
	}
L
Linus Torvalds 已提交
2648

2649 2650 2651
	/*
	 * Ensure UPF_DEAD is not set.
	 */
2652
	uport->flags &= ~UPF_DEAD;
2653

L
Linus Torvalds 已提交
2654
 out:
2655
	mutex_unlock(&port->mutex);
2656
	mutex_unlock(&port_mutex);
L
Linus Torvalds 已提交
2657 2658 2659 2660 2661 2662 2663

	return ret;
}

/**
 *	uart_remove_one_port - detach a driver defined port structure
 *	@drv: pointer to the uart low level driver structure for this port
2664
 *	@uport: uart port structure for this port
L
Linus Torvalds 已提交
2665 2666 2667 2668 2669
 *
 *	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.
 */
2670
int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
L
Linus Torvalds 已提交
2671
{
2672 2673
	struct uart_state *state = drv->state + uport->line;
	struct tty_port *port = &state->port;
2674
	struct tty_struct *tty;
2675
	int ret = 0;
L
Linus Torvalds 已提交
2676 2677 2678

	BUG_ON(in_interrupt());

2679
	if (state->uart_port != uport)
2680
		dev_alert(uport->dev, "Removing wrong port: %p != %p\n",
2681
			state->uart_port, uport);
L
Linus Torvalds 已提交
2682

2683
	mutex_lock(&port_mutex);
L
Linus Torvalds 已提交
2684

2685 2686 2687 2688
	/*
	 * Mark the port "dead" - this prevents any opens from
	 * succeeding while we shut down the port.
	 */
2689
	mutex_lock(&port->mutex);
2690 2691 2692 2693 2694
	if (!state->uart_port) {
		mutex_unlock(&port->mutex);
		ret = -EINVAL;
		goto out;
	}
2695 2696
	uport->flags |= UPF_DEAD;
	mutex_unlock(&port->mutex);
2697

L
Linus Torvalds 已提交
2698
	/*
2699
	 * Remove the devices from the tty layer
L
Linus Torvalds 已提交
2700
	 */
2701
	tty_unregister_device(drv->tty_driver, uport->line);
L
Linus Torvalds 已提交
2702

2703 2704
	tty = tty_port_tty_get(port);
	if (tty) {
2705
		tty_vhangup(port->tty);
2706 2707
		tty_kref_put(tty);
	}
2708

2709 2710 2711 2712 2713 2714
	/*
	 * If the port is used as a console, unregister it
	 */
	if (uart_console(uport))
		unregister_console(uport->cons);

2715 2716 2717
	/*
	 * Free the port IO and memory resources, if any.
	 */
2718 2719
	if (uport->type != PORT_UNKNOWN)
		uport->ops->release_port(uport);
2720
	kfree(uport->tty_groups);
2721 2722 2723 2724

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

A
Alan Cox 已提交
2727
	state->uart_port = NULL;
2728
out:
2729
	mutex_unlock(&port_mutex);
L
Linus Torvalds 已提交
2730

2731
	return ret;
L
Linus Torvalds 已提交
2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748
}

/*
 *	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:
2749 2750 2751
	case UPIO_MEM32:
	case UPIO_AU:
	case UPIO_TSI:
2752
		return (port1->mapbase == port2->mapbase);
L
Linus Torvalds 已提交
2753 2754 2755 2756 2757
	}
	return 0;
}
EXPORT_SYMBOL(uart_match_port);

J
Jiri Slaby 已提交
2758 2759 2760 2761
/**
 *	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
2762 2763
 *
 *	Caller must hold uport->lock
J
Jiri Slaby 已提交
2764 2765 2766
 */
void uart_handle_dcd_change(struct uart_port *uport, unsigned int status)
{
2767
	struct tty_port *port = &uport->state->port;
2768
	struct tty_struct *tty = port->tty;
2769
	struct tty_ldisc *ld;
J
Jiri Slaby 已提交
2770

2771 2772
	lockdep_assert_held_once(&uport->lock);

2773 2774 2775 2776 2777 2778 2779
	if (tty) {
		ld = tty_ldisc_ref(tty);
		if (ld) {
			if (ld->ops->dcd_change)
				ld->ops->dcd_change(tty, status);
			tty_ldisc_deref(ld);
		}
2780
	}
J
Jiri Slaby 已提交
2781 2782 2783

	uport->icount.dcd++;

2784
	if (uart_dcd_enabled(uport)) {
J
Jiri Slaby 已提交
2785 2786
		if (status)
			wake_up_interruptible(&port->open_wait);
2787 2788
		else if (tty)
			tty_hangup(tty);
J
Jiri Slaby 已提交
2789 2790 2791 2792 2793 2794 2795 2796
	}
}
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
2797 2798
 *
 *	Caller must hold uport->lock
J
Jiri Slaby 已提交
2799 2800 2801
 */
void uart_handle_cts_change(struct uart_port *uport, unsigned int status)
{
2802 2803
	lockdep_assert_held_once(&uport->lock);

J
Jiri Slaby 已提交
2804 2805
	uport->icount.cts++;

2806
	if (uart_cts_enabled(uport)) {
2807
		if (uport->hw_stopped) {
J
Jiri Slaby 已提交
2808
			if (status) {
2809
				uport->hw_stopped = 0;
J
Jiri Slaby 已提交
2810 2811 2812 2813 2814
				uport->ops->start_tx(uport);
				uart_write_wakeup(uport);
			}
		} else {
			if (!status) {
2815
				uport->hw_stopped = 1;
J
Jiri Slaby 已提交
2816 2817 2818 2819 2820 2821 2822
				uport->ops->stop_tx(uport);
			}
		}
	}
}
EXPORT_SYMBOL_GPL(uart_handle_cts_change);

J
Jiri Slaby 已提交
2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834
/**
 * 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 已提交
2835 2836 2837
void uart_insert_char(struct uart_port *port, unsigned int status,
		 unsigned int overrun, unsigned int ch, unsigned int flag)
{
J
Jiri Slaby 已提交
2838
	struct tty_port *tport = &port->state->port;
J
Jiri Slaby 已提交
2839 2840

	if ((status & port->ignore_status_mask & ~overrun) == 0)
J
Jiri Slaby 已提交
2841
		if (tty_insert_flip_char(tport, ch, flag) == 0)
2842
			++port->icount.buf_overrun;
J
Jiri Slaby 已提交
2843 2844 2845 2846 2847 2848

	/*
	 * 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 已提交
2849
		if (tty_insert_flip_char(tport, 0, TTY_OVERRUN) == 0)
2850
			++port->icount.buf_overrun;
J
Jiri Slaby 已提交
2851 2852 2853
}
EXPORT_SYMBOL_GPL(uart_insert_char);

L
Linus Torvalds 已提交
2854 2855 2856 2857 2858 2859 2860 2861 2862 2863
EXPORT_SYMBOL(uart_write_wakeup);
EXPORT_SYMBOL(uart_register_driver);
EXPORT_SYMBOL(uart_unregister_driver);
EXPORT_SYMBOL(uart_suspend_port);
EXPORT_SYMBOL(uart_resume_port);
EXPORT_SYMBOL(uart_add_one_port);
EXPORT_SYMBOL(uart_remove_one_port);

MODULE_DESCRIPTION("Serial driver core");
MODULE_LICENSE("GPL");