1// SPDX-License-Identifier: GPL-2.0+
   2/*
   3 *  Driver core for serial ports
   4 *
   5 *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
   6 *
   7 *  Copyright 1999 ARM Limited
   8 *  Copyright (C) 2000-2001 Deep Blue Solutions Ltd.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
   9 */
  10#include <linux/module.h>
  11#include <linux/tty.h>
  12#include <linux/tty_flip.h>
  13#include <linux/slab.h>
  14#include <linux/sched/signal.h>
  15#include <linux/init.h>
  16#include <linux/console.h>
  17#include <linux/of.h>
  18#include <linux/proc_fs.h>
  19#include <linux/seq_file.h>
  20#include <linux/device.h>
  21#include <linux/serial.h> /* for serial_state and serial_icounter_struct */
  22#include <linux/serial_core.h>
  23#include <linux/delay.h>
  24#include <linux/mutex.h>
  25
  26#include <linux/irq.h>
  27#include <linux/uaccess.h>
  28
  29/*
  30 * This is used to lock changes in serial line configuration.
  31 */
  32static DEFINE_MUTEX(port_mutex);
  33
  34/*
  35 * lockdep: port->lock is initialized in two places, but we
  36 *          want only one lock-class:
  37 */
  38static struct lock_class_key port_lock_key;
  39
  40#define HIGH_BITS_OFFSET	((sizeof(long)-sizeof(int))*8)
  41
  42static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
  43					struct ktermios *old_termios);
  44static void uart_wait_until_sent(struct tty_struct *tty, int timeout);
  45static void uart_change_pm(struct uart_state *state,
  46			   enum uart_pm_state pm_state);
  47
  48static void uart_port_shutdown(struct tty_port *port);
  49
  50static int uart_dcd_enabled(struct uart_port *uport)
  51{
  52	return !!(uport->status & UPSTAT_DCD_ENABLE);
  53}
  54
  55static inline struct uart_port *uart_port_ref(struct uart_state *state)
  56{
  57	if (atomic_add_unless(&state->refcount, 1, 0))
  58		return state->uart_port;
  59	return NULL;
  60}
  61
  62static inline void uart_port_deref(struct uart_port *uport)
  63{
  64	if (atomic_dec_and_test(&uport->state->refcount))
  65		wake_up(&uport->state->remove_wait);
  66}
  67
  68#define uart_port_lock(state, flags)					\
  69	({								\
  70		struct uart_port *__uport = uart_port_ref(state);	\
  71		if (__uport)						\
  72			spin_lock_irqsave(&__uport->lock, flags);	\
  73		__uport;						\
  74	})
  75
  76#define uart_port_unlock(uport, flags)					\
  77	({								\
  78		struct uart_port *__uport = uport;			\
  79		if (__uport) {						\
  80			spin_unlock_irqrestore(&__uport->lock, flags);	\
  81			uart_port_deref(__uport);			\
  82		}							\
  83	})
  84
  85static inline struct uart_port *uart_port_check(struct uart_state *state)
  86{
  87	lockdep_assert_held(&state->port.mutex);
  88	return state->uart_port;
  89}
  90
  91/*
  92 * This routine is used by the interrupt handler to schedule processing in
  93 * the software interrupt portion of the driver.
  94 */
  95void uart_write_wakeup(struct uart_port *port)
  96{
  97	struct uart_state *state = port->state;
  98	/*
  99	 * This means you called this function _after_ the port was
 100	 * closed.  No cookie for you.
 101	 */
 102	BUG_ON(!state);
 103	tty_port_tty_wakeup(&state->port);
 104}
 105
 106static void uart_stop(struct tty_struct *tty)
 107{
 108	struct uart_state *state = tty->driver_data;
 109	struct uart_port *port;
 110	unsigned long flags;
 111
 112	port = uart_port_lock(state, flags);
 113	if (port)
 114		port->ops->stop_tx(port);
 115	uart_port_unlock(port, flags);
 116}
 117
 118static void __uart_start(struct tty_struct *tty)
 119{
 120	struct uart_state *state = tty->driver_data;
 121	struct uart_port *port = state->uart_port;
 122
 123	if (port && !uart_tx_stopped(port))
 124		port->ops->start_tx(port);
 125}
 126
 127static void uart_start(struct tty_struct *tty)
 128{
 129	struct uart_state *state = tty->driver_data;
 130	struct uart_port *port;
 131	unsigned long flags;
 132
 133	port = uart_port_lock(state, flags);
 134	__uart_start(tty);
 135	uart_port_unlock(port, flags);
 136}
 137
 138static void
 139uart_update_mctrl(struct uart_port *port, unsigned int set, unsigned int clear)
 140{
 141	unsigned long flags;
 142	unsigned int old;
 143
 144	spin_lock_irqsave(&port->lock, flags);
 145	old = port->mctrl;
 146	port->mctrl = (old & ~clear) | set;
 147	if (old != port->mctrl)
 148		port->ops->set_mctrl(port, port->mctrl);
 149	spin_unlock_irqrestore(&port->lock, flags);
 150}
 151
 152#define uart_set_mctrl(port, set)	uart_update_mctrl(port, set, 0)
 153#define uart_clear_mctrl(port, clear)	uart_update_mctrl(port, 0, clear)
 154
 155static void uart_port_dtr_rts(struct uart_port *uport, int raise)
 156{
 157	int rs485_on = uport->rs485_config &&
 158		(uport->rs485.flags & SER_RS485_ENABLED);
 159	int RTS_after_send = !!(uport->rs485.flags & SER_RS485_RTS_AFTER_SEND);
 160
 161	if (raise) {
 162		if (rs485_on && !RTS_after_send) {
 163			uart_set_mctrl(uport, TIOCM_DTR);
 164			uart_clear_mctrl(uport, TIOCM_RTS);
 165		} else {
 166			uart_set_mctrl(uport, TIOCM_DTR | TIOCM_RTS);
 167		}
 168	} else {
 169		unsigned int clear = TIOCM_DTR;
 170
 171		clear |= (!rs485_on || !RTS_after_send) ? TIOCM_RTS : 0;
 172		uart_clear_mctrl(uport, clear);
 173	}
 174}
 175
 176/*
 177 * Startup the port.  This will be called once per open.  All calls
 178 * will be serialised by the per-port mutex.
 179 */
 180static int uart_port_startup(struct tty_struct *tty, struct uart_state *state,
 181		int init_hw)
 182{
 183	struct uart_port *uport = uart_port_check(state);
 
 184	unsigned long page;
 185	int retval = 0;
 186
 187	if (uport->type == PORT_UNKNOWN)
 188		return 1;
 189
 190	/*
 191	 * Make sure the device is in D0 state.
 192	 */
 193	uart_change_pm(state, UART_PM_STATE_ON);
 194
 195	/*
 196	 * Initialise and allocate the transmit and temporary
 197	 * buffer.
 198	 */
 199	if (!state->xmit.buf) {
 200		/* This is protected by the per port mutex */
 201		page = get_zeroed_page(GFP_KERNEL);
 202		if (!page)
 203			return -ENOMEM;
 204
 205		state->xmit.buf = (unsigned char *) page;
 206		uart_circ_clear(&state->xmit);
 207	}
 208
 209	retval = uport->ops->startup(uport);
 210	if (retval == 0) {
 211		if (uart_console(uport) && uport->cons->cflag) {
 212			tty->termios.c_cflag = uport->cons->cflag;
 213			uport->cons->cflag = 0;
 214		}
 215		/*
 216		 * Initialise the hardware port settings.
 217		 */
 218		uart_change_speed(tty, state, NULL);
 219
 220		/*
 221		 * Setup the RTS and DTR signals once the
 222		 * port is open and ready to respond.
 223		 */
 224		if (init_hw && C_BAUD(tty))
 225			uart_port_dtr_rts(uport, 1);
 
 
 
 
 
 
 
 
 
 226	}
 227
 228	/*
 229	 * This is to allow setserial on this port. People may want to set
 230	 * port/irq/type and then reconfigure the port properly if it failed
 231	 * now.
 232	 */
 233	if (retval && capable(CAP_SYS_ADMIN))
 234		return 1;
 235
 236	return retval;
 237}
 238
 239static int uart_startup(struct tty_struct *tty, struct uart_state *state,
 240		int init_hw)
 241{
 242	struct tty_port *port = &state->port;
 243	int retval;
 244
 245	if (tty_port_initialized(port))
 246		return 0;
 247
 
 
 
 
 
 
 248	retval = uart_port_startup(tty, state, init_hw);
 249	if (retval)
 250		set_bit(TTY_IO_ERROR, &tty->flags);
 
 
 
 251
 252	return retval;
 253}
 254
 255/*
 256 * This routine will shutdown a serial port; interrupts are disabled, and
 257 * DTR is dropped if the hangup on close termio flag is on.  Calls to
 258 * uart_shutdown are serialised by the per-port semaphore.
 259 *
 260 * uport == NULL if uart_port has already been removed
 261 */
 262static void uart_shutdown(struct tty_struct *tty, struct uart_state *state)
 263{
 264	struct uart_port *uport = uart_port_check(state);
 265	struct tty_port *port = &state->port;
 266
 267	/*
 268	 * Set the TTY IO error marker
 269	 */
 270	if (tty)
 271		set_bit(TTY_IO_ERROR, &tty->flags);
 272
 273	if (tty_port_initialized(port)) {
 274		tty_port_set_initialized(port, 0);
 275
 276		/*
 277		 * Turn off DTR and RTS early.
 278		 */
 279		if (uport && uart_console(uport) && tty)
 280			uport->cons->cflag = tty->termios.c_cflag;
 281
 282		if (!tty || C_HUPCL(tty))
 283			uart_port_dtr_rts(uport, 0);
 284
 285		uart_port_shutdown(port);
 286	}
 287
 288	/*
 289	 * It's possible for shutdown to be called after suspend if we get
 290	 * a DCD drop (hangup) at just the right time.  Clear suspended bit so
 291	 * we don't try to resume a port that has been shutdown.
 292	 */
 293	tty_port_set_suspended(port, 0);
 294
 295	/*
 296	 * Free the transmit buffer page.
 297	 */
 298	if (state->xmit.buf) {
 299		free_page((unsigned long)state->xmit.buf);
 300		state->xmit.buf = NULL;
 301	}
 302}
 303
 304/**
 305 *	uart_update_timeout - update per-port FIFO timeout.
 306 *	@port:  uart_port structure describing the port
 307 *	@cflag: termios cflag value
 308 *	@baud:  speed of the port
 309 *
 310 *	Set the port FIFO timeout value.  The @cflag value should
 311 *	reflect the actual hardware settings.
 312 */
 313void
 314uart_update_timeout(struct uart_port *port, unsigned int cflag,
 315		    unsigned int baud)
 316{
 317	unsigned int bits;
 318
 319	/* byte size and parity */
 320	switch (cflag & CSIZE) {
 321	case CS5:
 322		bits = 7;
 323		break;
 324	case CS6:
 325		bits = 8;
 326		break;
 327	case CS7:
 328		bits = 9;
 329		break;
 330	default:
 331		bits = 10;
 332		break; /* CS8 */
 333	}
 334
 335	if (cflag & CSTOPB)
 336		bits++;
 337	if (cflag & PARENB)
 338		bits++;
 339
 340	/*
 341	 * The total number of bits to be transmitted in the fifo.
 342	 */
 343	bits = bits * port->fifosize;
 344
 345	/*
 346	 * Figure the timeout to send the above number of bits.
 347	 * Add .02 seconds of slop
 348	 */
 349	port->timeout = (HZ * bits) / baud + HZ/50;
 350}
 351
 352EXPORT_SYMBOL(uart_update_timeout);
 353
 354/**
 355 *	uart_get_baud_rate - return baud rate for a particular port
 356 *	@port: uart_port structure describing the port in question.
 357 *	@termios: desired termios settings.
 358 *	@old: old termios (or NULL)
 359 *	@min: minimum acceptable baud rate
 360 *	@max: maximum acceptable baud rate
 361 *
 362 *	Decode the termios structure into a numeric baud rate,
 363 *	taking account of the magic 38400 baud rate (with spd_*
 364 *	flags), and mapping the %B0 rate to 9600 baud.
 365 *
 366 *	If the new baud rate is invalid, try the old termios setting.
 367 *	If it's still invalid, we try 9600 baud.
 368 *
 369 *	Update the @termios structure to reflect the baud rate
 370 *	we're actually going to be using. Don't do this for the case
 371 *	where B0 is requested ("hang up").
 372 */
 373unsigned int
 374uart_get_baud_rate(struct uart_port *port, struct ktermios *termios,
 375		   struct ktermios *old, unsigned int min, unsigned int max)
 376{
 377	unsigned int try;
 378	unsigned int baud;
 379	unsigned int altbaud;
 380	int hung_up = 0;
 381	upf_t flags = port->flags & UPF_SPD_MASK;
 382
 383	switch (flags) {
 384	case UPF_SPD_HI:
 385		altbaud = 57600;
 386		break;
 387	case UPF_SPD_VHI:
 388		altbaud = 115200;
 389		break;
 390	case UPF_SPD_SHI:
 391		altbaud = 230400;
 392		break;
 393	case UPF_SPD_WARP:
 394		altbaud = 460800;
 395		break;
 396	default:
 397		altbaud = 38400;
 398		break;
 399	}
 400
 401	for (try = 0; try < 2; try++) {
 402		baud = tty_termios_baud_rate(termios);
 403
 404		/*
 405		 * The spd_hi, spd_vhi, spd_shi, spd_warp kludge...
 406		 * Die! Die! Die!
 407		 */
 408		if (try == 0 && baud == 38400)
 409			baud = altbaud;
 410
 411		/*
 412		 * Special case: B0 rate.
 413		 */
 414		if (baud == 0) {
 415			hung_up = 1;
 416			baud = 9600;
 417		}
 418
 419		if (baud >= min && baud <= max)
 420			return baud;
 421
 422		/*
 423		 * Oops, the quotient was zero.  Try again with
 424		 * the old baud rate if possible.
 425		 */
 426		termios->c_cflag &= ~CBAUD;
 427		if (old) {
 428			baud = tty_termios_baud_rate(old);
 429			if (!hung_up)
 430				tty_termios_encode_baud_rate(termios,
 431								baud, baud);
 432			old = NULL;
 433			continue;
 434		}
 435
 436		/*
 437		 * As a last resort, if the range cannot be met then clip to
 438		 * the nearest chip supported rate.
 439		 */
 440		if (!hung_up) {
 441			if (baud <= min)
 442				tty_termios_encode_baud_rate(termios,
 443							min + 1, min + 1);
 444			else
 445				tty_termios_encode_baud_rate(termios,
 446							max - 1, max - 1);
 447		}
 448	}
 449	/* Should never happen */
 450	WARN_ON(1);
 451	return 0;
 452}
 453
 454EXPORT_SYMBOL(uart_get_baud_rate);
 455
 456/**
 457 *	uart_get_divisor - return uart clock divisor
 458 *	@port: uart_port structure describing the port.
 459 *	@baud: desired baud rate
 460 *
 461 *	Calculate the uart clock divisor for the port.
 462 */
 463unsigned int
 464uart_get_divisor(struct uart_port *port, unsigned int baud)
 465{
 466	unsigned int quot;
 467
 468	/*
 469	 * Old custom speed handling.
 470	 */
 471	if (baud == 38400 && (port->flags & UPF_SPD_MASK) == UPF_SPD_CUST)
 472		quot = port->custom_divisor;
 473	else
 474		quot = DIV_ROUND_CLOSEST(port->uartclk, 16 * baud);
 475
 476	return quot;
 477}
 478
 479EXPORT_SYMBOL(uart_get_divisor);
 480
 481/* Caller holds port mutex */
 482static void uart_change_speed(struct tty_struct *tty, struct uart_state *state,
 483					struct ktermios *old_termios)
 484{
 485	struct uart_port *uport = uart_port_check(state);
 
 486	struct ktermios *termios;
 487	int hw_stopped;
 488
 489	/*
 490	 * If we have no tty, termios, or the port does not exist,
 491	 * then we can't set the parameters for this port.
 492	 */
 493	if (!tty || uport->type == PORT_UNKNOWN)
 494		return;
 495
 496	termios = &tty->termios;
 497	uport->ops->set_termios(uport, termios, old_termios);
 498
 499	/*
 500	 * Set modem status enables based on termios cflag
 501	 */
 502	spin_lock_irq(&uport->lock);
 503	if (termios->c_cflag & CRTSCTS)
 504		uport->status |= UPSTAT_CTS_ENABLE;
 505	else
 506		uport->status &= ~UPSTAT_CTS_ENABLE;
 507
 508	if (termios->c_cflag & CLOCAL)
 509		uport->status &= ~UPSTAT_DCD_ENABLE;
 510	else
 511		uport->status |= UPSTAT_DCD_ENABLE;
 512
 513	/* reset sw-assisted CTS flow control based on (possibly) new mode */
 514	hw_stopped = uport->hw_stopped;
 515	uport->hw_stopped = uart_softcts_mode(uport) &&
 516				!(uport->ops->get_mctrl(uport) & TIOCM_CTS);
 517	if (uport->hw_stopped) {
 518		if (!hw_stopped)
 519			uport->ops->stop_tx(uport);
 520	} else {
 521		if (hw_stopped)
 522			__uart_start(tty);
 523	}
 524	spin_unlock_irq(&uport->lock);
 525}
 526
 527static int uart_put_char(struct tty_struct *tty, unsigned char c)
 
 528{
 529	struct uart_state *state = tty->driver_data;
 530	struct uart_port *port;
 531	struct circ_buf *circ;
 532	unsigned long flags;
 533	int ret = 0;
 534
 535	circ = &state->xmit;
 536	if (!circ->buf)
 537		return 0;
 538
 539	port = uart_port_lock(state, flags);
 540	if (port && uart_circ_chars_free(circ) != 0) {
 541		circ->buf[circ->head] = c;
 542		circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);
 543		ret = 1;
 544	}
 545	uart_port_unlock(port, flags);
 546	return ret;
 547}
 548
 
 
 
 
 
 
 
 549static void uart_flush_chars(struct tty_struct *tty)
 550{
 551	uart_start(tty);
 552}
 553
 554static int uart_write(struct tty_struct *tty,
 555					const unsigned char *buf, int count)
 556{
 557	struct uart_state *state = tty->driver_data;
 558	struct uart_port *port;
 559	struct circ_buf *circ;
 560	unsigned long flags;
 561	int c, ret = 0;
 562
 563	/*
 564	 * This means you called this function _after_ the port was
 565	 * closed.  No cookie for you.
 566	 */
 567	if (!state) {
 568		WARN_ON(1);
 569		return -EL3HLT;
 570	}
 571
 
 572	circ = &state->xmit;
 
 573	if (!circ->buf)
 574		return 0;
 575
 576	port = uart_port_lock(state, flags);
 577	while (port) {
 578		c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
 579		if (count < c)
 580			c = count;
 581		if (c <= 0)
 582			break;
 583		memcpy(circ->buf + circ->head, buf, c);
 584		circ->head = (circ->head + c) & (UART_XMIT_SIZE - 1);
 585		buf += c;
 586		count -= c;
 587		ret += c;
 588	}
 
 589
 590	__uart_start(tty);
 591	uart_port_unlock(port, flags);
 592	return ret;
 593}
 594
 595static int uart_write_room(struct tty_struct *tty)
 596{
 597	struct uart_state *state = tty->driver_data;
 598	struct uart_port *port;
 599	unsigned long flags;
 600	int ret;
 601
 602	port = uart_port_lock(state, flags);
 603	ret = uart_circ_chars_free(&state->xmit);
 604	uart_port_unlock(port, flags);
 605	return ret;
 606}
 607
 608static int uart_chars_in_buffer(struct tty_struct *tty)
 609{
 610	struct uart_state *state = tty->driver_data;
 611	struct uart_port *port;
 612	unsigned long flags;
 613	int ret;
 614
 615	port = uart_port_lock(state, flags);
 616	ret = uart_circ_chars_pending(&state->xmit);
 617	uart_port_unlock(port, flags);
 618	return ret;
 619}
 620
 621static void uart_flush_buffer(struct tty_struct *tty)
 622{
 623	struct uart_state *state = tty->driver_data;
 624	struct uart_port *port;
 625	unsigned long flags;
 626
 627	/*
 628	 * This means you called this function _after_ the port was
 629	 * closed.  No cookie for you.
 630	 */
 631	if (!state) {
 632		WARN_ON(1);
 633		return;
 634	}
 635
 
 636	pr_debug("uart_flush_buffer(%d) called\n", tty->index);
 637
 638	port = uart_port_lock(state, flags);
 639	if (!port)
 640		return;
 641	uart_circ_clear(&state->xmit);
 642	if (port->ops->flush_buffer)
 643		port->ops->flush_buffer(port);
 644	uart_port_unlock(port, flags);
 645	tty_port_tty_wakeup(&state->port);
 646}
 647
 648/*
 649 * This function is used to send a high-priority XON/XOFF character to
 650 * the device
 651 */
 652static void uart_send_xchar(struct tty_struct *tty, char ch)
 653{
 654	struct uart_state *state = tty->driver_data;
 655	struct uart_port *port;
 656	unsigned long flags;
 657
 658	port = uart_port_ref(state);
 659	if (!port)
 660		return;
 661
 662	if (port->ops->send_xchar)
 663		port->ops->send_xchar(port, ch);
 664	else {
 665		spin_lock_irqsave(&port->lock, flags);
 666		port->x_char = ch;
 667		if (ch)
 
 668			port->ops->start_tx(port);
 669		spin_unlock_irqrestore(&port->lock, flags);
 
 670	}
 671	uart_port_deref(port);
 672}
 673
 674static void uart_throttle(struct tty_struct *tty)
 675{
 676	struct uart_state *state = tty->driver_data;
 677	struct uart_port *port;
 678	upstat_t mask = 0;
 679
 680	port = uart_port_ref(state);
 681	if (!port)
 682		return;
 683
 684	if (I_IXOFF(tty))
 685		mask |= UPSTAT_AUTOXOFF;
 686	if (C_CRTSCTS(tty))
 687		mask |= UPSTAT_AUTORTS;
 688
 689	if (port->status & mask) {
 690		port->ops->throttle(port);
 691		mask &= ~port->status;
 692	}
 693
 694	if (mask & UPSTAT_AUTORTS)
 695		uart_clear_mctrl(port, TIOCM_RTS);
 696
 697	if (mask & UPSTAT_AUTOXOFF)
 698		uart_send_xchar(tty, STOP_CHAR(tty));
 699
 700	uart_port_deref(port);
 
 701}
 702
 703static void uart_unthrottle(struct tty_struct *tty)
 704{
 705	struct uart_state *state = tty->driver_data;
 706	struct uart_port *port;
 707	upstat_t mask = 0;
 708
 709	port = uart_port_ref(state);
 710	if (!port)
 711		return;
 712
 713	if (I_IXOFF(tty))
 714		mask |= UPSTAT_AUTOXOFF;
 715	if (C_CRTSCTS(tty))
 716		mask |= UPSTAT_AUTORTS;
 717
 718	if (port->status & mask) {
 719		port->ops->unthrottle(port);
 720		mask &= ~port->status;
 721	}
 722
 723	if (mask & UPSTAT_AUTORTS)
 724		uart_set_mctrl(port, TIOCM_RTS);
 725
 726	if (mask & UPSTAT_AUTOXOFF)
 727		uart_send_xchar(tty, START_CHAR(tty));
 
 728
 729	uart_port_deref(port);
 
 730}
 731
 732static int uart_get_info(struct tty_port *port, struct serial_struct *retinfo)
 
 733{
 734	struct uart_state *state = container_of(port, struct uart_state, port);
 735	struct uart_port *uport;
 736	int ret = -ENODEV;
 737
 738	memset(retinfo, 0, sizeof(*retinfo));
 739
 740	/*
 741	 * Ensure the state we copy is consistent and no hardware changes
 742	 * occur as we go
 743	 */
 744	mutex_lock(&port->mutex);
 745	uport = uart_port_check(state);
 746	if (!uport)
 747		goto out;
 748
 749	retinfo->type	    = uport->type;
 750	retinfo->line	    = uport->line;
 751	retinfo->port	    = uport->iobase;
 752	if (HIGH_BITS_OFFSET)
 753		retinfo->port_high = (long) uport->iobase >> HIGH_BITS_OFFSET;
 754	retinfo->irq		    = uport->irq;
 755	retinfo->flags	    = (__force int)uport->flags;
 756	retinfo->xmit_fifo_size  = uport->fifosize;
 757	retinfo->baud_base	    = uport->uartclk / 16;
 758	retinfo->close_delay	    = jiffies_to_msecs(port->close_delay) / 10;
 759	retinfo->closing_wait    = port->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 760				ASYNC_CLOSING_WAIT_NONE :
 761				jiffies_to_msecs(port->closing_wait) / 10;
 762	retinfo->custom_divisor  = uport->custom_divisor;
 763	retinfo->hub6	    = uport->hub6;
 764	retinfo->io_type         = uport->iotype;
 765	retinfo->iomem_reg_shift = uport->regshift;
 766	retinfo->iomem_base      = (void *)(unsigned long)uport->mapbase;
 
 767
 768	ret = 0;
 769out:
 
 
 
 
 
 770	mutex_unlock(&port->mutex);
 771	return ret;
 772}
 773
 774static int uart_get_info_user(struct tty_port *port,
 775			 struct serial_struct __user *retinfo)
 776{
 777	struct serial_struct tmp;
 778
 779	if (uart_get_info(port, &tmp) < 0)
 780		return -EIO;
 781
 782	if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
 783		return -EFAULT;
 784	return 0;
 785}
 786
 787static int uart_set_info(struct tty_struct *tty, struct tty_port *port,
 788			 struct uart_state *state,
 789			 struct serial_struct *new_info)
 790{
 791	struct uart_port *uport = uart_port_check(state);
 792	unsigned long new_port;
 793	unsigned int change_irq, change_port, closing_wait;
 794	unsigned int old_custom_divisor, close_delay;
 795	upf_t old_flags, new_flags;
 796	int retval = 0;
 797
 798	if (!uport)
 799		return -EIO;
 800
 801	new_port = new_info->port;
 802	if (HIGH_BITS_OFFSET)
 803		new_port += (unsigned long) new_info->port_high << HIGH_BITS_OFFSET;
 804
 805	new_info->irq = irq_canonicalize(new_info->irq);
 806	close_delay = msecs_to_jiffies(new_info->close_delay * 10);
 807	closing_wait = new_info->closing_wait == ASYNC_CLOSING_WAIT_NONE ?
 808			ASYNC_CLOSING_WAIT_NONE :
 809			msecs_to_jiffies(new_info->closing_wait * 10);
 810
 811
 812	change_irq  = !(uport->flags & UPF_FIXED_PORT)
 813		&& new_info->irq != uport->irq;
 814
 815	/*
 816	 * Since changing the 'type' of the port changes its resource
 817	 * allocations, we should treat type changes the same as
 818	 * IO port changes.
 819	 */
 820	change_port = !(uport->flags & UPF_FIXED_PORT)
 821		&& (new_port != uport->iobase ||
 822		    (unsigned long)new_info->iomem_base != uport->mapbase ||
 823		    new_info->hub6 != uport->hub6 ||
 824		    new_info->io_type != uport->iotype ||
 825		    new_info->iomem_reg_shift != uport->regshift ||
 826		    new_info->type != uport->type);
 827
 828	old_flags = uport->flags;
 829	new_flags = (__force upf_t)new_info->flags;
 830	old_custom_divisor = uport->custom_divisor;
 831
 832	if (!capable(CAP_SYS_ADMIN)) {
 833		retval = -EPERM;
 834		if (change_irq || change_port ||
 835		    (new_info->baud_base != uport->uartclk / 16) ||
 836		    (close_delay != port->close_delay) ||
 837		    (closing_wait != port->closing_wait) ||
 838		    (new_info->xmit_fifo_size &&
 839		     new_info->xmit_fifo_size != uport->fifosize) ||
 840		    (((new_flags ^ old_flags) & ~UPF_USR_MASK) != 0))
 841			goto exit;
 842		uport->flags = ((uport->flags & ~UPF_USR_MASK) |
 843			       (new_flags & UPF_USR_MASK));
 844		uport->custom_divisor = new_info->custom_divisor;
 845		goto check_and_exit;
 846	}
 847
 848	/*
 849	 * Ask the low level driver to verify the settings.
 850	 */
 851	if (uport->ops->verify_port)
 852		retval = uport->ops->verify_port(uport, new_info);
 853
 854	if ((new_info->irq >= nr_irqs) || (new_info->irq < 0) ||
 855	    (new_info->baud_base < 9600))
 856		retval = -EINVAL;
 857
 858	if (retval)
 859		goto exit;
 860
 861	if (change_port || change_irq) {
 862		retval = -EBUSY;
 863
 864		/*
 865		 * Make sure that we are the sole user of this port.
 866		 */
 867		if (tty_port_users(port) > 1)
 868			goto exit;
 869
 870		/*
 871		 * We need to shutdown the serial port at the old
 872		 * port/type/irq combination.
 873		 */
 874		uart_shutdown(tty, state);
 875	}
 876
 877	if (change_port) {
 878		unsigned long old_iobase, old_mapbase;
 879		unsigned int old_type, old_iotype, old_hub6, old_shift;
 880
 881		old_iobase = uport->iobase;
 882		old_mapbase = uport->mapbase;
 883		old_type = uport->type;
 884		old_hub6 = uport->hub6;
 885		old_iotype = uport->iotype;
 886		old_shift = uport->regshift;
 887
 888		/*
 889		 * Free and release old regions
 890		 */
 891		if (old_type != PORT_UNKNOWN && uport->ops->release_port)
 892			uport->ops->release_port(uport);
 893
 894		uport->iobase = new_port;
 895		uport->type = new_info->type;
 896		uport->hub6 = new_info->hub6;
 897		uport->iotype = new_info->io_type;
 898		uport->regshift = new_info->iomem_reg_shift;
 899		uport->mapbase = (unsigned long)new_info->iomem_base;
 900
 901		/*
 902		 * Claim and map the new regions
 903		 */
 904		if (uport->type != PORT_UNKNOWN && uport->ops->request_port) {
 905			retval = uport->ops->request_port(uport);
 906		} else {
 907			/* Always success - Jean II */
 908			retval = 0;
 909		}
 910
 911		/*
 912		 * If we fail to request resources for the
 913		 * new port, try to restore the old settings.
 914		 */
 915		if (retval) {
 916			uport->iobase = old_iobase;
 917			uport->type = old_type;
 918			uport->hub6 = old_hub6;
 919			uport->iotype = old_iotype;
 920			uport->regshift = old_shift;
 921			uport->mapbase = old_mapbase;
 922
 923			if (old_type != PORT_UNKNOWN) {
 924				retval = uport->ops->request_port(uport);
 925				/*
 926				 * If we failed to restore the old settings,
 927				 * we fail like this.
 928				 */
 929				if (retval)
 930					uport->type = PORT_UNKNOWN;
 931
 932				/*
 933				 * We failed anyway.
 934				 */
 935				retval = -EBUSY;
 936			}
 937
 938			/* Added to return the correct error -Ram Gupta */
 939			goto exit;
 940		}
 941	}
 942
 943	if (change_irq)
 944		uport->irq      = new_info->irq;
 945	if (!(uport->flags & UPF_FIXED_PORT))
 946		uport->uartclk  = new_info->baud_base * 16;
 947	uport->flags            = (uport->flags & ~UPF_CHANGE_MASK) |
 948				 (new_flags & UPF_CHANGE_MASK);
 949	uport->custom_divisor   = new_info->custom_divisor;
 950	port->close_delay     = close_delay;
 951	port->closing_wait    = closing_wait;
 952	if (new_info->xmit_fifo_size)
 953		uport->fifosize = new_info->xmit_fifo_size;
 954	port->low_latency = (uport->flags & UPF_LOW_LATENCY) ? 1 : 0;
 955
 956 check_and_exit:
 957	retval = 0;
 958	if (uport->type == PORT_UNKNOWN)
 959		goto exit;
 960	if (tty_port_initialized(port)) {
 961		if (((old_flags ^ uport->flags) & UPF_SPD_MASK) ||
 962		    old_custom_divisor != uport->custom_divisor) {
 963			/*
 964			 * If they're setting up a custom divisor or speed,
 965			 * instead of clearing it, then bitch about it.
 
 966			 */
 967			if (uport->flags & UPF_SPD_MASK) {
 968				dev_notice_ratelimited(uport->dev,
 969				       "%s sets custom speed on %s. This is deprecated.\n",
 970				      current->comm,
 971				      tty_name(port->tty));
 
 972			}
 973			uart_change_speed(tty, state, NULL);
 974		}
 975	} else {
 976		retval = uart_startup(tty, state, 1);
 977		if (retval == 0)
 978			tty_port_set_initialized(port, true);
 979		if (retval > 0)
 980			retval = 0;
 981	}
 982 exit:
 983	return retval;
 984}
 985
 986static int uart_set_info_user(struct tty_struct *tty, struct uart_state *state,
 987			 struct serial_struct __user *newinfo)
 988{
 989	struct serial_struct new_serial;
 990	struct tty_port *port = &state->port;
 991	int retval;
 992
 993	if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
 994		return -EFAULT;
 995
 996	/*
 997	 * This semaphore protects port->count.  It is also
 998	 * very useful to prevent opens.  Also, take the
 999	 * port configuration semaphore to make sure that a
1000	 * module insertion/removal doesn't change anything
1001	 * under us.
1002	 */
1003	mutex_lock(&port->mutex);
1004	retval = uart_set_info(tty, port, state, &new_serial);
1005	mutex_unlock(&port->mutex);
1006	return retval;
1007}
1008
1009/**
1010 *	uart_get_lsr_info	-	get line status register info
1011 *	@tty: tty associated with the UART
1012 *	@state: UART being queried
1013 *	@value: returned modem value
 
 
1014 */
1015static int uart_get_lsr_info(struct tty_struct *tty,
1016			struct uart_state *state, unsigned int __user *value)
1017{
1018	struct uart_port *uport = uart_port_check(state);
1019	unsigned int result;
1020
1021	result = uport->ops->tx_empty(uport);
1022
1023	/*
1024	 * If we're about to load something into the transmit
1025	 * register, we'll pretend the transmitter isn't empty to
1026	 * avoid a race condition (depending on when the transmit
1027	 * interrupt happens).
1028	 */
1029	if (uport->x_char ||
1030	    ((uart_circ_chars_pending(&state->xmit) > 0) &&
1031	     !uart_tx_stopped(uport)))
1032		result &= ~TIOCSER_TEMT;
1033
1034	return put_user(result, value);
1035}
1036
1037static int uart_tiocmget(struct tty_struct *tty)
1038{
1039	struct uart_state *state = tty->driver_data;
1040	struct tty_port *port = &state->port;
1041	struct uart_port *uport;
1042	int result = -EIO;
1043
1044	mutex_lock(&port->mutex);
1045	uport = uart_port_check(state);
1046	if (!uport)
1047		goto out;
1048
1049	if (!tty_io_error(tty)) {
1050		result = uport->mctrl;
1051		spin_lock_irq(&uport->lock);
1052		result |= uport->ops->get_mctrl(uport);
1053		spin_unlock_irq(&uport->lock);
1054	}
1055out:
1056	mutex_unlock(&port->mutex);
 
1057	return result;
1058}
1059
1060static int
1061uart_tiocmset(struct tty_struct *tty, unsigned int set, unsigned int clear)
1062{
1063	struct uart_state *state = tty->driver_data;
 
1064	struct tty_port *port = &state->port;
1065	struct uart_port *uport;
1066	int ret = -EIO;
1067
1068	mutex_lock(&port->mutex);
1069	uport = uart_port_check(state);
1070	if (!uport)
1071		goto out;
1072
1073	if (!tty_io_error(tty)) {
1074		uart_update_mctrl(uport, set, clear);
1075		ret = 0;
1076	}
1077out:
1078	mutex_unlock(&port->mutex);
1079	return ret;
1080}
1081
1082static int uart_break_ctl(struct tty_struct *tty, int break_state)
1083{
1084	struct uart_state *state = tty->driver_data;
1085	struct tty_port *port = &state->port;
1086	struct uart_port *uport;
1087	int ret = -EIO;
1088
1089	mutex_lock(&port->mutex);
1090	uport = uart_port_check(state);
1091	if (!uport)
1092		goto out;
1093
1094	if (uport->type != PORT_UNKNOWN)
1095		uport->ops->break_ctl(uport, break_state);
1096	ret = 0;
1097out:
1098	mutex_unlock(&port->mutex);
1099	return ret;
1100}
1101
1102static int uart_do_autoconfig(struct tty_struct *tty,struct uart_state *state)
1103{
 
1104	struct tty_port *port = &state->port;
1105	struct uart_port *uport;
1106	int flags, ret;
1107
1108	if (!capable(CAP_SYS_ADMIN))
1109		return -EPERM;
1110
1111	/*
1112	 * Take the per-port semaphore.  This prevents count from
1113	 * changing, and hence any extra opens of the port while
1114	 * we're auto-configuring.
1115	 */
1116	if (mutex_lock_interruptible(&port->mutex))
1117		return -ERESTARTSYS;
1118
1119	uport = uart_port_check(state);
1120	if (!uport) {
1121		ret = -EIO;
1122		goto out;
1123	}
1124
1125	ret = -EBUSY;
1126	if (tty_port_users(port) == 1) {
1127		uart_shutdown(tty, state);
1128
1129		/*
1130		 * If we already have a port type configured,
1131		 * we must release its resources.
1132		 */
1133		if (uport->type != PORT_UNKNOWN && uport->ops->release_port)
1134			uport->ops->release_port(uport);
1135
1136		flags = UART_CONFIG_TYPE;
1137		if (uport->flags & UPF_AUTO_IRQ)
1138			flags |= UART_CONFIG_IRQ;
1139
1140		/*
1141		 * This will claim the ports resources if
1142		 * a port is found.
1143		 */
1144		uport->ops->config_port(uport, flags);
1145
1146		ret = uart_startup(tty, state, 1);
1147		if (ret == 0)
1148			tty_port_set_initialized(port, true);
1149		if (ret > 0)
1150			ret = 0;
1151	}
1152out:
1153	mutex_unlock(&port->mutex);
1154	return ret;
1155}
1156
1157static void uart_enable_ms(struct uart_port *uport)
1158{
1159	/*
1160	 * Force modem status interrupts on
1161	 */
1162	if (uport->ops->enable_ms)
1163		uport->ops->enable_ms(uport);
1164}
1165
1166/*
1167 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
1168 * - mask passed in arg for lines of interest
1169 *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
1170 * Caller should use TIOCGICOUNT to see which one it was
1171 *
1172 * FIXME: This wants extracting into a common all driver implementation
1173 * of TIOCMWAIT using tty_port.
1174 */
1175static int uart_wait_modem_status(struct uart_state *state, unsigned long arg)
 
1176{
1177	struct uart_port *uport;
1178	struct tty_port *port = &state->port;
1179	DECLARE_WAITQUEUE(wait, current);
1180	struct uart_icount cprev, cnow;
1181	int ret;
1182
1183	/*
1184	 * note the counters on entry
1185	 */
1186	uport = uart_port_ref(state);
1187	if (!uport)
1188		return -EIO;
1189	spin_lock_irq(&uport->lock);
1190	memcpy(&cprev, &uport->icount, sizeof(struct uart_icount));
1191	uart_enable_ms(uport);
 
 
 
 
1192	spin_unlock_irq(&uport->lock);
1193
1194	add_wait_queue(&port->delta_msr_wait, &wait);
1195	for (;;) {
1196		spin_lock_irq(&uport->lock);
1197		memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
1198		spin_unlock_irq(&uport->lock);
1199
1200		set_current_state(TASK_INTERRUPTIBLE);
1201
1202		if (((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) ||
1203		    ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) ||
1204		    ((arg & TIOCM_CD)  && (cnow.dcd != cprev.dcd)) ||
1205		    ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts))) {
1206			ret = 0;
1207			break;
1208		}
1209
1210		schedule();
1211
1212		/* see if a signal did it */
1213		if (signal_pending(current)) {
1214			ret = -ERESTARTSYS;
1215			break;
1216		}
1217
1218		cprev = cnow;
1219	}
1220	__set_current_state(TASK_RUNNING);
 
1221	remove_wait_queue(&port->delta_msr_wait, &wait);
1222	uart_port_deref(uport);
1223
1224	return ret;
1225}
1226
1227/*
1228 * Get counter of input serial line interrupts (DCD,RI,DSR,CTS)
1229 * Return: write counters to the user passed counter struct
1230 * NB: both 1->0 and 0->1 transitions are counted except for
1231 *     RI where only 0->1 is counted.
1232 */
1233static int uart_get_icount(struct tty_struct *tty,
1234			  struct serial_icounter_struct *icount)
1235{
1236	struct uart_state *state = tty->driver_data;
1237	struct uart_icount cnow;
1238	struct uart_port *uport;
1239
1240	uport = uart_port_ref(state);
1241	if (!uport)
1242		return -EIO;
1243	spin_lock_irq(&uport->lock);
1244	memcpy(&cnow, &uport->icount, sizeof(struct uart_icount));
1245	spin_unlock_irq(&uport->lock);
1246	uart_port_deref(uport);
1247
1248	icount->cts         = cnow.cts;
1249	icount->dsr         = cnow.dsr;
1250	icount->rng         = cnow.rng;
1251	icount->dcd         = cnow.dcd;
1252	icount->rx          = cnow.rx;
1253	icount->tx          = cnow.tx;
1254	icount->frame       = cnow.frame;
1255	icount->overrun     = cnow.overrun;
1256	icount->parity      = cnow.parity;
1257	icount->brk         = cnow.brk;
1258	icount->buf_overrun = cnow.buf_overrun;
1259
1260	return 0;
1261}
1262
1263static int uart_get_rs485_config(struct uart_port *port,
1264			 struct serial_rs485 __user *rs485)
1265{
1266	unsigned long flags;
1267	struct serial_rs485 aux;
1268
1269	spin_lock_irqsave(&port->lock, flags);
1270	aux = port->rs485;
1271	spin_unlock_irqrestore(&port->lock, flags);
1272
1273	if (copy_to_user(rs485, &aux, sizeof(aux)))
1274		return -EFAULT;
1275
1276	return 0;
1277}
1278
1279static int uart_set_rs485_config(struct uart_port *port,
1280			 struct serial_rs485 __user *rs485_user)
1281{
1282	struct serial_rs485 rs485;
1283	int ret;
1284	unsigned long flags;
1285
1286	if (!port->rs485_config)
1287		return -ENOIOCTLCMD;
1288
1289	if (copy_from_user(&rs485, rs485_user, sizeof(*rs485_user)))
1290		return -EFAULT;
1291
1292	spin_lock_irqsave(&port->lock, flags);
1293	ret = port->rs485_config(port, &rs485);
1294	spin_unlock_irqrestore(&port->lock, flags);
1295	if (ret)
1296		return ret;
1297
1298	if (copy_to_user(rs485_user, &port->rs485, sizeof(port->rs485)))
1299		return -EFAULT;
1300
1301	return 0;
1302}
1303
1304/*
1305 * Called via sys_ioctl.  We can use spin_lock_irq() here.
1306 */
1307static int
1308uart_ioctl(struct tty_struct *tty, unsigned int cmd, unsigned long arg)
 
1309{
1310	struct uart_state *state = tty->driver_data;
1311	struct tty_port *port = &state->port;
1312	struct uart_port *uport;
1313	void __user *uarg = (void __user *)arg;
1314	int ret = -ENOIOCTLCMD;
1315
1316
1317	/*
1318	 * These ioctls don't rely on the hardware to be present.
1319	 */
1320	switch (cmd) {
1321	case TIOCGSERIAL:
1322		ret = uart_get_info_user(port, uarg);
1323		break;
1324
1325	case TIOCSSERIAL:
1326		down_write(&tty->termios_rwsem);
1327		ret = uart_set_info_user(tty, state, uarg);
1328		up_write(&tty->termios_rwsem);
1329		break;
1330
1331	case TIOCSERCONFIG:
1332		down_write(&tty->termios_rwsem);
1333		ret = uart_do_autoconfig(tty, state);
1334		up_write(&tty->termios_rwsem);
1335		break;
1336
1337	case TIOCSERGWILD: /* obsolete */
1338	case TIOCSERSWILD: /* obsolete */
1339		ret = 0;
1340		break;
1341	}
1342
1343	if (ret != -ENOIOCTLCMD)
1344		goto out;
1345
1346	if (tty_io_error(tty)) {
1347		ret = -EIO;
1348		goto out;
1349	}
1350
1351	/*
1352	 * The following should only be used when hardware is present.
1353	 */
1354	switch (cmd) {
1355	case TIOCMIWAIT:
1356		ret = uart_wait_modem_status(state, arg);
1357		break;
1358	}
1359
1360	if (ret != -ENOIOCTLCMD)
1361		goto out;
1362
1363	mutex_lock(&port->mutex);
1364	uport = uart_port_check(state);
1365
1366	if (!uport || tty_io_error(tty)) {
1367		ret = -EIO;
1368		goto out_up;
1369	}
1370
1371	/*
1372	 * All these rely on hardware being present and need to be
1373	 * protected against the tty being hung up.
1374	 */
1375
1376	switch (cmd) {
1377	case TIOCSERGETLSR: /* Get line status register */
1378		ret = uart_get_lsr_info(tty, state, uarg);
1379		break;
1380
1381	case TIOCGRS485:
1382		ret = uart_get_rs485_config(uport, uarg);
1383		break;
1384
1385	case TIOCSRS485:
1386		ret = uart_set_rs485_config(uport, uarg);
1387		break;
1388	default:
1389		if (uport->ops->ioctl)
1390			ret = uport->ops->ioctl(uport, cmd, arg);
1391		break;
1392	}
 
1393out_up:
1394	mutex_unlock(&port->mutex);
1395out:
1396	return ret;
1397}
1398
1399static void uart_set_ldisc(struct tty_struct *tty)
1400{
1401	struct uart_state *state = tty->driver_data;
1402	struct uart_port *uport;
1403
1404	mutex_lock(&state->port.mutex);
1405	uport = uart_port_check(state);
1406	if (uport && uport->ops->set_ldisc)
1407		uport->ops->set_ldisc(uport, &tty->termios);
1408	mutex_unlock(&state->port.mutex);
1409}
1410
1411static void uart_set_termios(struct tty_struct *tty,
1412						struct ktermios *old_termios)
1413{
1414	struct uart_state *state = tty->driver_data;
1415	struct uart_port *uport;
 
1416	unsigned int cflag = tty->termios.c_cflag;
1417	unsigned int iflag_mask = IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK;
1418	bool sw_changed = false;
1419
1420	mutex_lock(&state->port.mutex);
1421	uport = uart_port_check(state);
1422	if (!uport)
1423		goto out;
1424
1425	/*
1426	 * Drivers doing software flow control also need to know
1427	 * about changes to these input settings.
1428	 */
1429	if (uport->flags & UPF_SOFT_FLOW) {
1430		iflag_mask |= IXANY|IXON|IXOFF;
1431		sw_changed =
1432		   tty->termios.c_cc[VSTART] != old_termios->c_cc[VSTART] ||
1433		   tty->termios.c_cc[VSTOP] != old_termios->c_cc[VSTOP];
1434	}
1435
1436	/*
1437	 * These are the bits that are used to setup various
1438	 * flags in the low level driver. We can ignore the Bfoo
1439	 * bits in c_cflag; c_[io]speed will always be set
1440	 * appropriately by set_termios() in tty_ioctl.c
1441	 */
1442	if ((cflag ^ old_termios->c_cflag) == 0 &&
1443	    tty->termios.c_ospeed == old_termios->c_ospeed &&
1444	    tty->termios.c_ispeed == old_termios->c_ispeed &&
1445	    ((tty->termios.c_iflag ^ old_termios->c_iflag) & iflag_mask) == 0 &&
1446	    !sw_changed) {
1447		goto out;
1448	}
1449
1450	uart_change_speed(tty, state, old_termios);
1451	/* reload cflag from termios; port driver may have overriden flags */
1452	cflag = tty->termios.c_cflag;
1453
1454	/* Handle transition to B0 status */
1455	if ((old_termios->c_cflag & CBAUD) && !(cflag & CBAUD))
1456		uart_clear_mctrl(uport, TIOCM_RTS | TIOCM_DTR);
1457	/* Handle transition away from B0 status */
1458	else if (!(old_termios->c_cflag & CBAUD) && (cflag & CBAUD)) {
1459		unsigned int mask = TIOCM_DTR;
1460		if (!(cflag & CRTSCTS) || !tty_throttled(tty))
 
1461			mask |= TIOCM_RTS;
1462		uart_set_mctrl(uport, mask);
1463	}
1464out:
1465	mutex_unlock(&state->port.mutex);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1466}
1467
1468/*
1469 * Calls to uart_close() are serialised via the tty_lock in
1470 *   drivers/tty/tty_io.c:tty_release()
1471 *   drivers/tty/tty_io.c:do_tty_hangup()
 
1472 */
1473static void uart_close(struct tty_struct *tty, struct file *filp)
1474{
1475	struct uart_state *state = tty->driver_data;
 
 
 
1476
1477	if (!state) {
1478		struct uart_driver *drv = tty->driver->driver_state;
1479		struct tty_port *port;
1480
1481		state = drv->state + tty->index;
1482		port = &state->port;
1483		spin_lock_irq(&port->lock);
1484		--port->count;
1485		spin_unlock_irq(&port->lock);
1486		return;
1487	}
1488
1489	pr_debug("uart_close(%d) called\n", tty->index);
 
1490
1491	tty_port_close(tty->port, tty, filp);
1492}
1493
1494static void uart_tty_port_shutdown(struct tty_port *port)
1495{
1496	struct uart_state *state = container_of(port, struct uart_state, port);
1497	struct uart_port *uport = uart_port_check(state);
1498
1499	/*
1500	 * At this point, we stop accepting input.  To do this, we
1501	 * disable the receive line status interrupts.
1502	 */
1503	if (WARN(!uport, "detached port still initialized!\n"))
1504		return;
 
 
 
 
 
 
 
 
 
 
1505
1506	spin_lock_irq(&uport->lock);
1507	uport->ops->stop_rx(uport);
1508	spin_unlock_irq(&uport->lock);
1509
1510	uart_port_shutdown(port);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1511
1512	/*
1513	 * It's possible for shutdown to be called after suspend if we get
1514	 * a DCD drop (hangup) at just the right time.  Clear suspended bit so
1515	 * we don't try to resume a port that has been shutdown.
1516	 */
1517	tty_port_set_suspended(port, 0);
1518
1519	uart_change_pm(state, UART_PM_STATE_OFF);
 
 
1520
 
1521}
1522
1523static void uart_wait_until_sent(struct tty_struct *tty, int timeout)
1524{
1525	struct uart_state *state = tty->driver_data;
1526	struct uart_port *port;
1527	unsigned long char_time, expire;
1528
1529	port = uart_port_ref(state);
1530	if (!port)
1531		return;
1532
1533	if (port->type == PORT_UNKNOWN || port->fifosize == 0) {
1534		uart_port_deref(port);
1535		return;
1536	}
1537
1538	/*
1539	 * Set the check interval to be 1/5 of the estimated time to
1540	 * send a single character, and make it at least 1.  The check
1541	 * interval should also be less than the timeout.
1542	 *
1543	 * Note: we have to use pretty tight timings here to satisfy
1544	 * the NIST-PCTS.
1545	 */
1546	char_time = (port->timeout - HZ/50) / port->fifosize;
1547	char_time = char_time / 5;
1548	if (char_time == 0)
1549		char_time = 1;
1550	if (timeout && timeout < char_time)
1551		char_time = timeout;
1552
1553	/*
1554	 * If the transmitter hasn't cleared in twice the approximate
1555	 * amount of time to send the entire FIFO, it probably won't
1556	 * ever clear.  This assumes the UART isn't doing flow
1557	 * control, which is currently the case.  Hence, if it ever
1558	 * takes longer than port->timeout, this is probably due to a
1559	 * UART bug of some kind.  So, we clamp the timeout parameter at
1560	 * 2*port->timeout.
1561	 */
1562	if (timeout == 0 || timeout > 2 * port->timeout)
1563		timeout = 2 * port->timeout;
1564
1565	expire = jiffies + timeout;
1566
1567	pr_debug("uart_wait_until_sent(%d), jiffies=%lu, expire=%lu...\n",
1568		port->line, jiffies, expire);
1569
1570	/*
1571	 * Check whether the transmitter is empty every 'char_time'.
1572	 * 'timeout' / 'expire' give us the maximum amount of time
1573	 * we wait.
1574	 */
1575	while (!port->ops->tx_empty(port)) {
1576		msleep_interruptible(jiffies_to_msecs(char_time));
1577		if (signal_pending(current))
1578			break;
1579		if (time_after(jiffies, expire))
1580			break;
1581	}
1582	uart_port_deref(port);
1583}
1584
1585/*
1586 * Calls to uart_hangup() are serialised by the tty_lock in
1587 *   drivers/tty/tty_io.c:do_tty_hangup()
1588 * This runs from a workqueue and can sleep for a _short_ time only.
1589 */
1590static void uart_hangup(struct tty_struct *tty)
1591{
1592	struct uart_state *state = tty->driver_data;
1593	struct tty_port *port = &state->port;
1594	struct uart_port *uport;
1595	unsigned long flags;
1596
1597	pr_debug("uart_hangup(%d)\n", tty->index);
1598
1599	mutex_lock(&port->mutex);
1600	uport = uart_port_check(state);
1601	WARN(!uport, "hangup of detached port!\n");
1602
1603	if (tty_port_active(port)) {
1604		uart_flush_buffer(tty);
1605		uart_shutdown(tty, state);
1606		spin_lock_irqsave(&port->lock, flags);
1607		port->count = 0;
 
1608		spin_unlock_irqrestore(&port->lock, flags);
1609		tty_port_set_active(port, 0);
1610		tty_port_tty_set(port, NULL);
1611		if (uport && !uart_console(uport))
1612			uart_change_pm(state, UART_PM_STATE_OFF);
1613		wake_up_interruptible(&port->open_wait);
1614		wake_up_interruptible(&port->delta_msr_wait);
1615	}
1616	mutex_unlock(&port->mutex);
1617}
1618
1619/* uport == NULL if uart_port has already been removed */
 
 
 
 
1620static void uart_port_shutdown(struct tty_port *port)
1621{
1622	struct uart_state *state = container_of(port, struct uart_state, port);
1623	struct uart_port *uport = uart_port_check(state);
1624
1625	/*
1626	 * clear delta_msr_wait queue to avoid mem leaks: we may free
1627	 * the irq here so the queue might never be woken up.  Note
1628	 * that we won't end up waiting on delta_msr_wait again since
1629	 * any outstanding file descriptors should be pointing at
1630	 * hung_up_tty_fops now.
1631	 */
1632	wake_up_interruptible(&port->delta_msr_wait);
1633
1634	/*
1635	 * Free the IRQ and disable the port.
1636	 */
1637	if (uport)
1638		uport->ops->shutdown(uport);
1639
1640	/*
1641	 * Ensure that the IRQ handler isn't running on another CPU.
1642	 */
1643	if (uport)
1644		synchronize_irq(uport->irq);
1645}
1646
1647static int uart_carrier_raised(struct tty_port *port)
1648{
1649	struct uart_state *state = container_of(port, struct uart_state, port);
1650	struct uart_port *uport;
1651	int mctrl;
1652
1653	uport = uart_port_ref(state);
1654	/*
1655	 * Should never observe uport == NULL since checks for hangup should
1656	 * abort the tty_port_block_til_ready() loop before checking for carrier
1657	 * raised -- but report carrier raised if it does anyway so open will
1658	 * continue and not sleep
1659	 */
1660	if (WARN_ON(!uport))
1661		return 1;
1662	spin_lock_irq(&uport->lock);
1663	uart_enable_ms(uport);
1664	mctrl = uport->ops->get_mctrl(uport);
1665	spin_unlock_irq(&uport->lock);
1666	uart_port_deref(uport);
1667	if (mctrl & TIOCM_CAR)
1668		return 1;
1669	return 0;
1670}
1671
1672static void uart_dtr_rts(struct tty_port *port, int raise)
1673{
1674	struct uart_state *state = container_of(port, struct uart_state, port);
1675	struct uart_port *uport;
1676
1677	uport = uart_port_ref(state);
1678	if (!uport)
1679		return;
1680	uart_port_dtr_rts(uport, raise);
1681	uart_port_deref(uport);
1682}
1683
1684/*
1685 * Calls to uart_open are serialised by the tty_lock in
1686 *   drivers/tty/tty_io.c:tty_open()
1687 * Note that if this fails, then uart_close() _will_ be called.
1688 *
1689 * In time, we want to scrap the "opening nonpresent ports"
1690 * behaviour and implement an alternative way for setserial
1691 * to set base addresses/ports/types.  This will allow us to
1692 * get rid of a certain amount of extra tests.
1693 */
1694static int uart_open(struct tty_struct *tty, struct file *filp)
1695{
1696	struct uart_driver *drv = tty->driver->driver_state;
1697	int retval, line = tty->index;
1698	struct uart_state *state = drv->state + line;
 
1699
1700	tty->driver_data = state;
1701
1702	retval = tty_port_open(&state->port, tty, filp);
1703	if (retval > 0)
1704		retval = 0;
1705
1706	return retval;
1707}
 
 
 
 
 
 
 
 
 
1708
1709static int uart_port_activate(struct tty_port *port, struct tty_struct *tty)
1710{
1711	struct uart_state *state = container_of(port, struct uart_state, port);
1712	struct uart_port *uport;
 
1713
1714	uport = uart_port_check(state);
1715	if (!uport || uport->flags & UPF_DEAD)
1716		return -ENXIO;
 
 
 
 
 
 
 
1717
1718	port->low_latency = (uport->flags & UPF_LOW_LATENCY) ? 1 : 0;
 
 
 
 
 
 
1719
1720	/*
1721	 * Start up the serial port.
1722	 */
1723	return uart_startup(tty, state, 0);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1724}
1725
1726static const char *uart_type(struct uart_port *port)
1727{
1728	const char *str = NULL;
1729
1730	if (port->ops->type)
1731		str = port->ops->type(port);
1732
1733	if (!str)
1734		str = "unknown";
1735
1736	return str;
1737}
1738
1739#ifdef CONFIG_PROC_FS
1740
1741static void uart_line_info(struct seq_file *m, struct uart_driver *drv, int i)
1742{
1743	struct uart_state *state = drv->state + i;
1744	struct tty_port *port = &state->port;
1745	enum uart_pm_state pm_state;
1746	struct uart_port *uport;
1747	char stat_buf[32];
1748	unsigned int status;
1749	int mmio;
1750
1751	mutex_lock(&port->mutex);
1752	uport = uart_port_check(state);
1753	if (!uport)
1754		goto out;
1755
1756	mmio = uport->iotype >= UPIO_MEM;
1757	seq_printf(m, "%d: uart:%s %s%08llX irq:%d",
1758			uport->line, uart_type(uport),
1759			mmio ? "mmio:0x" : "port:",
1760			mmio ? (unsigned long long)uport->mapbase
1761			     : (unsigned long long)uport->iobase,
1762			uport->irq);
1763
1764	if (uport->type == PORT_UNKNOWN) {
1765		seq_putc(m, '\n');
1766		goto out;
1767	}
1768
1769	if (capable(CAP_SYS_ADMIN)) {
 
1770		pm_state = state->pm_state;
1771		if (pm_state != UART_PM_STATE_ON)
1772			uart_change_pm(state, UART_PM_STATE_ON);
1773		spin_lock_irq(&uport->lock);
1774		status = uport->ops->get_mctrl(uport);
1775		spin_unlock_irq(&uport->lock);
1776		if (pm_state != UART_PM_STATE_ON)
1777			uart_change_pm(state, pm_state);
 
1778
1779		seq_printf(m, " tx:%d rx:%d",
1780				uport->icount.tx, uport->icount.rx);
1781		if (uport->icount.frame)
1782			seq_printf(m, " fe:%d",	uport->icount.frame);
 
1783		if (uport->icount.parity)
1784			seq_printf(m, " pe:%d",	uport->icount.parity);
 
1785		if (uport->icount.brk)
1786			seq_printf(m, " brk:%d", uport->icount.brk);
 
1787		if (uport->icount.overrun)
1788			seq_printf(m, " oe:%d", uport->icount.overrun);
1789		if (uport->icount.buf_overrun)
1790			seq_printf(m, " bo:%d", uport->icount.buf_overrun);
1791
1792#define INFOBIT(bit, str) \
1793	if (uport->mctrl & (bit)) \
1794		strncat(stat_buf, (str), sizeof(stat_buf) - \
1795			strlen(stat_buf) - 2)
1796#define STATBIT(bit, str) \
1797	if (status & (bit)) \
1798		strncat(stat_buf, (str), sizeof(stat_buf) - \
1799		       strlen(stat_buf) - 2)
1800
1801		stat_buf[0] = '\0';
1802		stat_buf[1] = '\0';
1803		INFOBIT(TIOCM_RTS, "|RTS");
1804		STATBIT(TIOCM_CTS, "|CTS");
1805		INFOBIT(TIOCM_DTR, "|DTR");
1806		STATBIT(TIOCM_DSR, "|DSR");
1807		STATBIT(TIOCM_CAR, "|CD");
1808		STATBIT(TIOCM_RNG, "|RI");
1809		if (stat_buf[0])
1810			stat_buf[0] = ' ';
1811
1812		seq_puts(m, stat_buf);
1813	}
1814	seq_putc(m, '\n');
1815#undef STATBIT
1816#undef INFOBIT
1817out:
1818	mutex_unlock(&port->mutex);
1819}
1820
1821static int uart_proc_show(struct seq_file *m, void *v)
1822{
1823	struct tty_driver *ttydrv = m->private;
1824	struct uart_driver *drv = ttydrv->driver_state;
1825	int i;
1826
1827	seq_printf(m, "serinfo:1.0 driver%s%s revision:%s\n", "", "", "");
 
1828	for (i = 0; i < drv->nr; i++)
1829		uart_line_info(m, drv, i);
1830	return 0;
1831}
1832
1833static int uart_proc_open(struct inode *inode, struct file *file)
1834{
1835	return single_open(file, uart_proc_show, PDE_DATA(inode));
1836}
1837
1838static const struct file_operations uart_proc_fops = {
1839	.owner		= THIS_MODULE,
1840	.open		= uart_proc_open,
1841	.read		= seq_read,
1842	.llseek		= seq_lseek,
1843	.release	= single_release,
1844};
1845#endif
1846
1847#if defined(CONFIG_SERIAL_CORE_CONSOLE) || defined(CONFIG_CONSOLE_POLL)
1848/**
1849 *	uart_console_write - write a console message to a serial port
1850 *	@port: the port to write the message
1851 *	@s: array of characters
1852 *	@count: number of characters in string to write
1853 *	@putchar: function to write character to port
1854 */
1855void uart_console_write(struct uart_port *port, const char *s,
1856			unsigned int count,
1857			void (*putchar)(struct uart_port *, int))
1858{
1859	unsigned int i;
1860
1861	for (i = 0; i < count; i++, s++) {
1862		if (*s == '\n')
1863			putchar(port, '\r');
1864		putchar(port, *s);
1865	}
1866}
1867EXPORT_SYMBOL_GPL(uart_console_write);
1868
1869/*
1870 *	Check whether an invalid uart number has been specified, and
1871 *	if so, search for the first available port that does have
1872 *	console support.
1873 */
1874struct uart_port * __init
1875uart_get_console(struct uart_port *ports, int nr, struct console *co)
1876{
1877	int idx = co->index;
1878
1879	if (idx < 0 || idx >= nr || (ports[idx].iobase == 0 &&
1880				     ports[idx].membase == NULL))
1881		for (idx = 0; idx < nr; idx++)
1882			if (ports[idx].iobase != 0 ||
1883			    ports[idx].membase != NULL)
1884				break;
1885
1886	co->index = idx;
1887
1888	return ports + idx;
1889}
1890
1891/**
1892 *	uart_parse_earlycon - Parse earlycon options
1893 *	@p:	  ptr to 2nd field (ie., just beyond '<name>,')
1894 *	@iotype:  ptr for decoded iotype (out)
1895 *	@addr:    ptr for decoded mapbase/iobase (out)
1896 *	@options: ptr for <options> field; NULL if not present (out)
1897 *
1898 *	Decodes earlycon kernel command line parameters of the form
1899 *	   earlycon=<name>,io|mmio|mmio16|mmio32|mmio32be|mmio32native,<addr>,<options>
1900 *	   console=<name>,io|mmio|mmio16|mmio32|mmio32be|mmio32native,<addr>,<options>
1901 *
1902 *	The optional form
1903 *	   earlycon=<name>,0x<addr>,<options>
1904 *	   console=<name>,0x<addr>,<options>
1905 *	is also accepted; the returned @iotype will be UPIO_MEM.
1906 *
1907 *	Returns 0 on success or -EINVAL on failure
1908 */
1909int uart_parse_earlycon(char *p, unsigned char *iotype, resource_size_t *addr,
1910			char **options)
1911{
1912	if (strncmp(p, "mmio,", 5) == 0) {
1913		*iotype = UPIO_MEM;
1914		p += 5;
1915	} else if (strncmp(p, "mmio16,", 7) == 0) {
1916		*iotype = UPIO_MEM16;
1917		p += 7;
1918	} else if (strncmp(p, "mmio32,", 7) == 0) {
1919		*iotype = UPIO_MEM32;
1920		p += 7;
1921	} else if (strncmp(p, "mmio32be,", 9) == 0) {
1922		*iotype = UPIO_MEM32BE;
1923		p += 9;
1924	} else if (strncmp(p, "mmio32native,", 13) == 0) {
1925		*iotype = IS_ENABLED(CONFIG_CPU_BIG_ENDIAN) ?
1926			UPIO_MEM32BE : UPIO_MEM32;
1927		p += 13;
1928	} else if (strncmp(p, "io,", 3) == 0) {
1929		*iotype = UPIO_PORT;
1930		p += 3;
1931	} else if (strncmp(p, "0x", 2) == 0) {
1932		*iotype = UPIO_MEM;
1933	} else {
1934		return -EINVAL;
1935	}
1936
1937	/*
1938	 * Before you replace it with kstrtoull(), think about options separator
1939	 * (',') it will not tolerate
1940	 */
1941	*addr = simple_strtoull(p, NULL, 0);
1942	p = strchr(p, ',');
1943	if (p)
1944		p++;
1945
1946	*options = p;
1947	return 0;
1948}
1949EXPORT_SYMBOL_GPL(uart_parse_earlycon);
1950
1951/**
1952 *	uart_parse_options - Parse serial port baud/parity/bits/flow control.
1953 *	@options: pointer to option string
1954 *	@baud: pointer to an 'int' variable for the baud rate.
1955 *	@parity: pointer to an 'int' variable for the parity.
1956 *	@bits: pointer to an 'int' variable for the number of data bits.
1957 *	@flow: pointer to an 'int' variable for the flow control character.
1958 *
1959 *	uart_parse_options decodes a string containing the serial console
1960 *	options.  The format of the string is <baud><parity><bits><flow>,
1961 *	eg: 115200n8r
1962 */
1963void
1964uart_parse_options(const char *options, int *baud, int *parity,
1965		   int *bits, int *flow)
1966{
1967	const char *s = options;
1968
1969	*baud = simple_strtoul(s, NULL, 10);
1970	while (*s >= '0' && *s <= '9')
1971		s++;
1972	if (*s)
1973		*parity = *s++;
1974	if (*s)
1975		*bits = *s++ - '0';
1976	if (*s)
1977		*flow = *s;
1978}
1979EXPORT_SYMBOL_GPL(uart_parse_options);
1980
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1981/**
1982 *	uart_set_options - setup the serial console parameters
1983 *	@port: pointer to the serial ports uart_port structure
1984 *	@co: console pointer
1985 *	@baud: baud rate
1986 *	@parity: parity character - 'n' (none), 'o' (odd), 'e' (even)
1987 *	@bits: number of data bits
1988 *	@flow: flow control character - 'r' (rts)
1989 */
1990int
1991uart_set_options(struct uart_port *port, struct console *co,
1992		 int baud, int parity, int bits, int flow)
1993{
1994	struct ktermios termios;
1995	static struct ktermios dummy;
 
1996
1997	/*
1998	 * Ensure that the serial console lock is initialised
1999	 * early.
2000	 * If this port is a console, then the spinlock is already
2001	 * initialised.
2002	 */
2003	if (!(uart_console(port) && (port->cons->flags & CON_ENABLED))) {
2004		spin_lock_init(&port->lock);
2005		lockdep_set_class(&port->lock, &port_lock_key);
2006	}
2007
2008	memset(&termios, 0, sizeof(struct ktermios));
2009
2010	termios.c_cflag |= CREAD | HUPCL | CLOCAL;
2011	tty_termios_encode_baud_rate(&termios, baud, baud);
 
 
 
 
 
 
 
 
2012
2013	if (bits == 7)
2014		termios.c_cflag |= CS7;
2015	else
2016		termios.c_cflag |= CS8;
2017
2018	switch (parity) {
2019	case 'o': case 'O':
2020		termios.c_cflag |= PARODD;
2021		/*fall through*/
2022	case 'e': case 'E':
2023		termios.c_cflag |= PARENB;
2024		break;
2025	}
2026
2027	if (flow == 'r')
2028		termios.c_cflag |= CRTSCTS;
2029
2030	/*
2031	 * some uarts on other side don't support no flow control.
2032	 * So we set * DTR in host uart to make them happy
2033	 */
2034	port->mctrl |= TIOCM_DTR;
2035
2036	port->ops->set_termios(port, &termios, &dummy);
2037	/*
2038	 * Allow the setting of the UART parameters with a NULL console
2039	 * too:
2040	 */
2041	if (co)
2042		co->cflag = termios.c_cflag;
2043
2044	return 0;
2045}
2046EXPORT_SYMBOL_GPL(uart_set_options);
2047#endif /* CONFIG_SERIAL_CORE_CONSOLE */
2048
2049/**
2050 * uart_change_pm - set power state of the port
2051 *
2052 * @state: port descriptor
2053 * @pm_state: new state
2054 *
2055 * Locking: port->mutex has to be held
2056 */
2057static void uart_change_pm(struct uart_state *state,
2058			   enum uart_pm_state pm_state)
2059{
2060	struct uart_port *port = uart_port_check(state);
2061
2062	if (state->pm_state != pm_state) {
2063		if (port && port->ops->pm)
2064			port->ops->pm(port, pm_state, state->pm_state);
2065		state->pm_state = pm_state;
2066	}
2067}
2068
2069struct uart_match {
2070	struct uart_port *port;
2071	struct uart_driver *driver;
2072};
2073
2074static int serial_match_port(struct device *dev, void *data)
2075{
2076	struct uart_match *match = data;
2077	struct tty_driver *tty_drv = match->driver->tty_driver;
2078	dev_t devt = MKDEV(tty_drv->major, tty_drv->minor_start) +
2079		match->port->line;
2080
2081	return dev->devt == devt; /* Actually, only one tty per port */
2082}
2083
2084int uart_suspend_port(struct uart_driver *drv, struct uart_port *uport)
2085{
2086	struct uart_state *state = drv->state + uport->line;
2087	struct tty_port *port = &state->port;
2088	struct device *tty_dev;
2089	struct uart_match match = {uport, drv};
2090
2091	mutex_lock(&port->mutex);
2092
2093	tty_dev = device_find_child(uport->dev, &match, serial_match_port);
2094	if (tty_dev && device_may_wakeup(tty_dev)) {
2095		enable_irq_wake(uport->irq);
 
2096		put_device(tty_dev);
2097		mutex_unlock(&port->mutex);
2098		return 0;
2099	}
2100	put_device(tty_dev);
2101
2102	/* Nothing to do if the console is not suspending */
2103	if (!console_suspend_enabled && uart_console(uport))
2104		goto unlock;
2105
2106	uport->suspended = 1;
2107
2108	if (tty_port_initialized(port)) {
2109		const struct uart_ops *ops = uport->ops;
2110		int tries;
2111
2112		tty_port_set_suspended(port, 1);
2113		tty_port_set_initialized(port, 0);
 
2114
2115		spin_lock_irq(&uport->lock);
2116		ops->stop_tx(uport);
2117		ops->set_mctrl(uport, 0);
2118		ops->stop_rx(uport);
2119		spin_unlock_irq(&uport->lock);
 
2120
2121		/*
2122		 * Wait for the transmitter to empty.
2123		 */
2124		for (tries = 3; !ops->tx_empty(uport) && tries; tries--)
2125			msleep(10);
2126		if (!tries)
2127			dev_err(uport->dev, "%s: Unable to drain transmitter\n",
2128				uport->name);
 
 
 
 
2129
2130		ops->shutdown(uport);
 
2131	}
2132
2133	/*
2134	 * Disable the console device before suspending.
2135	 */
2136	if (uart_console(uport))
2137		console_stop(uport->cons);
2138
2139	uart_change_pm(state, UART_PM_STATE_OFF);
2140unlock:
 
2141	mutex_unlock(&port->mutex);
2142
2143	return 0;
2144}
2145
2146int uart_resume_port(struct uart_driver *drv, struct uart_port *uport)
2147{
2148	struct uart_state *state = drv->state + uport->line;
2149	struct tty_port *port = &state->port;
2150	struct device *tty_dev;
2151	struct uart_match match = {uport, drv};
2152	struct ktermios termios;
2153
2154	mutex_lock(&port->mutex);
2155
2156	tty_dev = device_find_child(uport->dev, &match, serial_match_port);
2157	if (!uport->suspended && device_may_wakeup(tty_dev)) {
2158		if (irqd_is_wakeup_set(irq_get_irq_data((uport->irq))))
2159			disable_irq_wake(uport->irq);
 
 
2160		put_device(tty_dev);
2161		mutex_unlock(&port->mutex);
2162		return 0;
2163	}
2164	put_device(tty_dev);
2165	uport->suspended = 0;
2166
2167	/*
2168	 * Re-enable the console device after suspending.
2169	 */
2170	if (uart_console(uport)) {
2171		/*
2172		 * First try to use the console cflag setting.
2173		 */
2174		memset(&termios, 0, sizeof(struct ktermios));
2175		termios.c_cflag = uport->cons->cflag;
2176
2177		/*
2178		 * If that's unset, use the tty termios setting.
2179		 */
2180		if (port->tty && termios.c_cflag == 0)
2181			termios = port->tty->termios;
2182
2183		if (console_suspend_enabled)
2184			uart_change_pm(state, UART_PM_STATE_ON);
2185		uport->ops->set_termios(uport, &termios, NULL);
2186		if (console_suspend_enabled)
2187			console_start(uport->cons);
2188	}
2189
2190	if (tty_port_suspended(port)) {
2191		const struct uart_ops *ops = uport->ops;
2192		int ret;
2193
2194		uart_change_pm(state, UART_PM_STATE_ON);
2195		spin_lock_irq(&uport->lock);
2196		ops->set_mctrl(uport, 0);
2197		spin_unlock_irq(&uport->lock);
2198		if (console_suspend_enabled || !uart_console(uport)) {
2199			/* Protected by port mutex for now */
2200			struct tty_struct *tty = port->tty;
2201			ret = ops->startup(uport);
2202			if (ret == 0) {
2203				if (tty)
2204					uart_change_speed(tty, state, NULL);
2205				spin_lock_irq(&uport->lock);
2206				ops->set_mctrl(uport, uport->mctrl);
2207				ops->start_tx(uport);
2208				spin_unlock_irq(&uport->lock);
2209				tty_port_set_initialized(port, 1);
2210			} else {
2211				/*
2212				 * Failed to resume - maybe hardware went away?
2213				 * Clear the "initialized" flag so we won't try
2214				 * to call the low level drivers shutdown method.
2215				 */
2216				uart_shutdown(tty, state);
2217			}
2218		}
2219
2220		tty_port_set_suspended(port, 0);
2221	}
2222
2223	mutex_unlock(&port->mutex);
2224
2225	return 0;
2226}
2227
2228static inline void
2229uart_report_port(struct uart_driver *drv, struct uart_port *port)
2230{
2231	char address[64];
2232
2233	switch (port->iotype) {
2234	case UPIO_PORT:
2235		snprintf(address, sizeof(address), "I/O 0x%lx", port->iobase);
2236		break;
2237	case UPIO_HUB6:
2238		snprintf(address, sizeof(address),
2239			 "I/O 0x%lx offset 0x%x", port->iobase, port->hub6);
2240		break;
2241	case UPIO_MEM:
2242	case UPIO_MEM16:
2243	case UPIO_MEM32:
2244	case UPIO_MEM32BE:
2245	case UPIO_AU:
2246	case UPIO_TSI:
2247		snprintf(address, sizeof(address),
2248			 "MMIO 0x%llx", (unsigned long long)port->mapbase);
2249		break;
2250	default:
2251		strlcpy(address, "*unknown*", sizeof(address));
2252		break;
2253	}
2254
2255	pr_info("%s%s%s at %s (irq = %d, base_baud = %d) is a %s\n",
2256	       port->dev ? dev_name(port->dev) : "",
2257	       port->dev ? ": " : "",
2258	       port->name,
 
2259	       address, port->irq, port->uartclk / 16, uart_type(port));
2260}
2261
2262static void
2263uart_configure_port(struct uart_driver *drv, struct uart_state *state,
2264		    struct uart_port *port)
2265{
2266	unsigned int flags;
2267
2268	/*
2269	 * If there isn't a port here, don't do anything further.
2270	 */
2271	if (!port->iobase && !port->mapbase && !port->membase)
2272		return;
2273
2274	/*
2275	 * Now do the auto configuration stuff.  Note that config_port
2276	 * is expected to claim the resources and map the port for us.
2277	 */
2278	flags = 0;
2279	if (port->flags & UPF_AUTO_IRQ)
2280		flags |= UART_CONFIG_IRQ;
2281	if (port->flags & UPF_BOOT_AUTOCONF) {
2282		if (!(port->flags & UPF_FIXED_TYPE)) {
2283			port->type = PORT_UNKNOWN;
2284			flags |= UART_CONFIG_TYPE;
2285		}
2286		port->ops->config_port(port, flags);
2287	}
2288
2289	if (port->type != PORT_UNKNOWN) {
2290		unsigned long flags;
2291
2292		uart_report_port(drv, port);
2293
2294		/* Power up port for set_mctrl() */
2295		uart_change_pm(state, UART_PM_STATE_ON);
2296
2297		/*
2298		 * Ensure that the modem control lines are de-activated.
2299		 * keep the DTR setting that is set in uart_set_options()
2300		 * We probably don't need a spinlock around this, but
2301		 */
2302		spin_lock_irqsave(&port->lock, flags);
2303		port->ops->set_mctrl(port, port->mctrl & TIOCM_DTR);
2304		spin_unlock_irqrestore(&port->lock, flags);
2305
2306		/*
2307		 * If this driver supports console, and it hasn't been
2308		 * successfully registered yet, try to re-register it.
2309		 * It may be that the port was not available.
2310		 */
2311		if (port->cons && !(port->cons->flags & CON_ENABLED))
2312			register_console(port->cons);
2313
2314		/*
2315		 * Power down all ports by default, except the
2316		 * console if we have one.
2317		 */
2318		if (!uart_console(port))
2319			uart_change_pm(state, UART_PM_STATE_OFF);
2320	}
2321}
2322
2323#ifdef CONFIG_CONSOLE_POLL
2324
2325static int uart_poll_init(struct tty_driver *driver, int line, char *options)
2326{
2327	struct uart_driver *drv = driver->driver_state;
2328	struct uart_state *state = drv->state + line;
2329	struct tty_port *tport;
2330	struct uart_port *port;
2331	int baud = 9600;
2332	int bits = 8;
2333	int parity = 'n';
2334	int flow = 'n';
2335	int ret = 0;
2336
2337	tport = &state->port;
2338	mutex_lock(&tport->mutex);
2339
2340	port = uart_port_check(state);
2341	if (!port || !(port->ops->poll_get_char && port->ops->poll_put_char)) {
2342		ret = -1;
2343		goto out;
2344	}
2345
2346	if (port->ops->poll_init) {
 
 
 
 
2347		/*
2348		 * We don't set initialized as we only initialized the hw,
2349		 * e.g. state->xmit is still uninitialized.
2350		 */
2351		if (!tty_port_initialized(tport))
2352			ret = port->ops->poll_init(port);
 
 
 
2353	}
2354
2355	if (!ret && options) {
2356		uart_parse_options(options, &baud, &parity, &bits, &flow);
2357		ret = uart_set_options(port, NULL, baud, parity, bits, flow);
2358	}
2359out:
2360	mutex_unlock(&tport->mutex);
2361	return ret;
2362}
2363
2364static int uart_poll_get_char(struct tty_driver *driver, int line)
2365{
2366	struct uart_driver *drv = driver->driver_state;
2367	struct uart_state *state = drv->state + line;
2368	struct uart_port *port;
2369	int ret = -1;
2370
2371	port = uart_port_ref(state);
2372	if (port) {
2373		ret = port->ops->poll_get_char(port);
2374		uart_port_deref(port);
2375	}
2376
2377	return ret;
 
2378}
2379
2380static void uart_poll_put_char(struct tty_driver *driver, int line, char ch)
2381{
2382	struct uart_driver *drv = driver->driver_state;
2383	struct uart_state *state = drv->state + line;
2384	struct uart_port *port;
2385
2386	port = uart_port_ref(state);
2387	if (!port)
2388		return;
2389
2390	if (ch == '\n')
2391		port->ops->poll_put_char(port, '\r');
2392	port->ops->poll_put_char(port, ch);
2393	uart_port_deref(port);
2394}
2395#endif
2396
2397static const struct tty_operations uart_ops = {
2398	.open		= uart_open,
2399	.close		= uart_close,
2400	.write		= uart_write,
2401	.put_char	= uart_put_char,
2402	.flush_chars	= uart_flush_chars,
2403	.write_room	= uart_write_room,
2404	.chars_in_buffer= uart_chars_in_buffer,
2405	.flush_buffer	= uart_flush_buffer,
2406	.ioctl		= uart_ioctl,
2407	.throttle	= uart_throttle,
2408	.unthrottle	= uart_unthrottle,
2409	.send_xchar	= uart_send_xchar,
2410	.set_termios	= uart_set_termios,
2411	.set_ldisc	= uart_set_ldisc,
2412	.stop		= uart_stop,
2413	.start		= uart_start,
2414	.hangup		= uart_hangup,
2415	.break_ctl	= uart_break_ctl,
2416	.wait_until_sent= uart_wait_until_sent,
2417#ifdef CONFIG_PROC_FS
2418	.proc_fops	= &uart_proc_fops,
2419#endif
2420	.tiocmget	= uart_tiocmget,
2421	.tiocmset	= uart_tiocmset,
2422	.get_icount	= uart_get_icount,
2423#ifdef CONFIG_CONSOLE_POLL
2424	.poll_init	= uart_poll_init,
2425	.poll_get_char	= uart_poll_get_char,
2426	.poll_put_char	= uart_poll_put_char,
2427#endif
2428};
2429
2430static const struct tty_port_operations uart_port_ops = {
 
 
2431	.carrier_raised = uart_carrier_raised,
2432	.dtr_rts	= uart_dtr_rts,
2433	.activate	= uart_port_activate,
2434	.shutdown	= uart_tty_port_shutdown,
2435};
2436
2437/**
2438 *	uart_register_driver - register a driver with the uart core layer
2439 *	@drv: low level driver structure
2440 *
2441 *	Register a uart driver with the core driver.  We in turn register
2442 *	with the tty layer, and initialise the core driver per-port state.
2443 *
2444 *	We have a proc file in /proc/tty/driver which is named after the
2445 *	normal driver.
2446 *
2447 *	drv->port should be NULL, and the per-port structures should be
2448 *	registered using uart_add_one_port after this call has succeeded.
2449 */
2450int uart_register_driver(struct uart_driver *drv)
2451{
2452	struct tty_driver *normal;
2453	int i, retval;
2454
2455	BUG_ON(drv->state);
2456
2457	/*
2458	 * Maybe we should be using a slab cache for this, especially if
2459	 * we have a large number of ports to handle.
2460	 */
2461	drv->state = kzalloc(sizeof(struct uart_state) * drv->nr, GFP_KERNEL);
2462	if (!drv->state)
2463		goto out;
2464
2465	normal = alloc_tty_driver(drv->nr);
2466	if (!normal)
2467		goto out_kfree;
2468
2469	drv->tty_driver = normal;
2470
2471	normal->driver_name	= drv->driver_name;
2472	normal->name		= drv->dev_name;
2473	normal->major		= drv->major;
2474	normal->minor_start	= drv->minor;
2475	normal->type		= TTY_DRIVER_TYPE_SERIAL;
2476	normal->subtype		= SERIAL_TYPE_NORMAL;
2477	normal->init_termios	= tty_std_termios;
2478	normal->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2479	normal->init_termios.c_ispeed = normal->init_termios.c_ospeed = 9600;
2480	normal->flags		= TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
2481	normal->driver_state    = drv;
2482	tty_set_operations(normal, &uart_ops);
2483
2484	/*
2485	 * Initialise the UART state(s).
2486	 */
2487	for (i = 0; i < drv->nr; i++) {
2488		struct uart_state *state = drv->state + i;
2489		struct tty_port *port = &state->port;
2490
2491		tty_port_init(port);
2492		port->ops = &uart_port_ops;
 
 
2493	}
2494
2495	retval = tty_register_driver(normal);
2496	if (retval >= 0)
2497		return retval;
2498
2499	for (i = 0; i < drv->nr; i++)
2500		tty_port_destroy(&drv->state[i].port);
2501	put_tty_driver(normal);
2502out_kfree:
2503	kfree(drv->state);
2504out:
2505	return -ENOMEM;
2506}
2507
2508/**
2509 *	uart_unregister_driver - remove a driver from the uart core layer
2510 *	@drv: low level driver structure
2511 *
2512 *	Remove all references to a driver from the core driver.  The low
2513 *	level driver must have removed all its ports via the
2514 *	uart_remove_one_port() if it registered them with uart_add_one_port().
2515 *	(ie, drv->port == NULL)
2516 */
2517void uart_unregister_driver(struct uart_driver *drv)
2518{
2519	struct tty_driver *p = drv->tty_driver;
2520	unsigned int i;
2521
2522	tty_unregister_driver(p);
2523	put_tty_driver(p);
2524	for (i = 0; i < drv->nr; i++)
2525		tty_port_destroy(&drv->state[i].port);
2526	kfree(drv->state);
2527	drv->state = NULL;
2528	drv->tty_driver = NULL;
2529}
2530
2531struct tty_driver *uart_console_device(struct console *co, int *index)
2532{
2533	struct uart_driver *p = co->data;
2534	*index = co->index;
2535	return p->tty_driver;
2536}
2537
2538static ssize_t uart_get_attr_uartclk(struct device *dev,
2539	struct device_attribute *attr, char *buf)
2540{
2541	struct serial_struct tmp;
2542	struct tty_port *port = dev_get_drvdata(dev);
2543
2544	uart_get_info(port, &tmp);
2545	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.baud_base * 16);
2546}
2547
2548static ssize_t uart_get_attr_type(struct device *dev,
2549	struct device_attribute *attr, char *buf)
2550{
2551	struct serial_struct tmp;
2552	struct tty_port *port = dev_get_drvdata(dev);
2553
2554	uart_get_info(port, &tmp);
2555	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.type);
2556}
2557static ssize_t uart_get_attr_line(struct device *dev,
2558	struct device_attribute *attr, char *buf)
2559{
2560	struct serial_struct tmp;
2561	struct tty_port *port = dev_get_drvdata(dev);
2562
2563	uart_get_info(port, &tmp);
2564	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.line);
2565}
2566
2567static ssize_t uart_get_attr_port(struct device *dev,
2568	struct device_attribute *attr, char *buf)
2569{
2570	struct serial_struct tmp;
2571	struct tty_port *port = dev_get_drvdata(dev);
2572	unsigned long ioaddr;
2573
2574	uart_get_info(port, &tmp);
2575	ioaddr = tmp.port;
2576	if (HIGH_BITS_OFFSET)
2577		ioaddr |= (unsigned long)tmp.port_high << HIGH_BITS_OFFSET;
2578	return snprintf(buf, PAGE_SIZE, "0x%lX\n", ioaddr);
2579}
2580
2581static ssize_t uart_get_attr_irq(struct device *dev,
2582	struct device_attribute *attr, char *buf)
2583{
2584	struct serial_struct tmp;
2585	struct tty_port *port = dev_get_drvdata(dev);
2586
2587	uart_get_info(port, &tmp);
2588	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.irq);
2589}
2590
2591static ssize_t uart_get_attr_flags(struct device *dev,
2592	struct device_attribute *attr, char *buf)
2593{
2594	struct serial_struct tmp;
2595	struct tty_port *port = dev_get_drvdata(dev);
2596
2597	uart_get_info(port, &tmp);
2598	return snprintf(buf, PAGE_SIZE, "0x%X\n", tmp.flags);
2599}
2600
2601static ssize_t uart_get_attr_xmit_fifo_size(struct device *dev,
2602	struct device_attribute *attr, char *buf)
2603{
2604	struct serial_struct tmp;
2605	struct tty_port *port = dev_get_drvdata(dev);
2606
2607	uart_get_info(port, &tmp);
2608	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.xmit_fifo_size);
2609}
2610
2611
2612static ssize_t uart_get_attr_close_delay(struct device *dev,
2613	struct device_attribute *attr, char *buf)
2614{
2615	struct serial_struct tmp;
2616	struct tty_port *port = dev_get_drvdata(dev);
2617
2618	uart_get_info(port, &tmp);
2619	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.close_delay);
2620}
2621
2622
2623static ssize_t uart_get_attr_closing_wait(struct device *dev,
2624	struct device_attribute *attr, char *buf)
2625{
2626	struct serial_struct tmp;
2627	struct tty_port *port = dev_get_drvdata(dev);
2628
2629	uart_get_info(port, &tmp);
2630	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.closing_wait);
2631}
2632
2633static ssize_t uart_get_attr_custom_divisor(struct device *dev,
2634	struct device_attribute *attr, char *buf)
2635{
2636	struct serial_struct tmp;
2637	struct tty_port *port = dev_get_drvdata(dev);
2638
2639	uart_get_info(port, &tmp);
2640	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.custom_divisor);
2641}
2642
2643static ssize_t uart_get_attr_io_type(struct device *dev,
2644	struct device_attribute *attr, char *buf)
2645{
2646	struct serial_struct tmp;
2647	struct tty_port *port = dev_get_drvdata(dev);
2648
2649	uart_get_info(port, &tmp);
2650	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.io_type);
2651}
2652
2653static ssize_t uart_get_attr_iomem_base(struct device *dev,
2654	struct device_attribute *attr, char *buf)
2655{
2656	struct serial_struct tmp;
2657	struct tty_port *port = dev_get_drvdata(dev);
2658
2659	uart_get_info(port, &tmp);
2660	return snprintf(buf, PAGE_SIZE, "0x%lX\n", (unsigned long)tmp.iomem_base);
2661}
2662
2663static ssize_t uart_get_attr_iomem_reg_shift(struct device *dev,
2664	struct device_attribute *attr, char *buf)
2665{
2666	struct serial_struct tmp;
2667	struct tty_port *port = dev_get_drvdata(dev);
2668
2669	uart_get_info(port, &tmp);
2670	return snprintf(buf, PAGE_SIZE, "%d\n", tmp.iomem_reg_shift);
2671}
2672
2673static DEVICE_ATTR(type, S_IRUSR | S_IRGRP, uart_get_attr_type, NULL);
2674static DEVICE_ATTR(line, S_IRUSR | S_IRGRP, uart_get_attr_line, NULL);
2675static DEVICE_ATTR(port, S_IRUSR | S_IRGRP, uart_get_attr_port, NULL);
2676static DEVICE_ATTR(irq, S_IRUSR | S_IRGRP, uart_get_attr_irq, NULL);
2677static DEVICE_ATTR(flags, S_IRUSR | S_IRGRP, uart_get_attr_flags, NULL);
2678static DEVICE_ATTR(xmit_fifo_size, S_IRUSR | S_IRGRP, uart_get_attr_xmit_fifo_size, NULL);
2679static DEVICE_ATTR(uartclk, S_IRUSR | S_IRGRP, uart_get_attr_uartclk, NULL);
2680static DEVICE_ATTR(close_delay, S_IRUSR | S_IRGRP, uart_get_attr_close_delay, NULL);
2681static DEVICE_ATTR(closing_wait, S_IRUSR | S_IRGRP, uart_get_attr_closing_wait, NULL);
2682static DEVICE_ATTR(custom_divisor, S_IRUSR | S_IRGRP, uart_get_attr_custom_divisor, NULL);
2683static DEVICE_ATTR(io_type, S_IRUSR | S_IRGRP, uart_get_attr_io_type, NULL);
2684static DEVICE_ATTR(iomem_base, S_IRUSR | S_IRGRP, uart_get_attr_iomem_base, NULL);
2685static DEVICE_ATTR(iomem_reg_shift, S_IRUSR | S_IRGRP, uart_get_attr_iomem_reg_shift, NULL);
2686
2687static struct attribute *tty_dev_attrs[] = {
2688	&dev_attr_type.attr,
2689	&dev_attr_line.attr,
2690	&dev_attr_port.attr,
2691	&dev_attr_irq.attr,
2692	&dev_attr_flags.attr,
2693	&dev_attr_xmit_fifo_size.attr,
2694	&dev_attr_uartclk.attr,
2695	&dev_attr_close_delay.attr,
2696	&dev_attr_closing_wait.attr,
2697	&dev_attr_custom_divisor.attr,
2698	&dev_attr_io_type.attr,
2699	&dev_attr_iomem_base.attr,
2700	&dev_attr_iomem_reg_shift.attr,
2701	NULL,
2702	};
2703
2704static const struct attribute_group tty_dev_attr_group = {
2705	.attrs = tty_dev_attrs,
2706	};
2707
 
 
 
 
 
 
2708/**
2709 *	uart_add_one_port - attach a driver-defined port structure
2710 *	@drv: pointer to the uart low level driver structure for this port
2711 *	@uport: uart port structure to use for this port.
2712 *
2713 *	This allows the driver to register its own uart_port structure
2714 *	with the core driver.  The main purpose is to allow the low
2715 *	level uart drivers to expand uart_port, rather than having yet
2716 *	more levels of structures.
2717 */
2718int uart_add_one_port(struct uart_driver *drv, struct uart_port *uport)
2719{
2720	struct uart_state *state;
2721	struct tty_port *port;
2722	int ret = 0;
2723	struct device *tty_dev;
2724	int num_groups;
2725
2726	BUG_ON(in_interrupt());
2727
2728	if (uport->line >= drv->nr)
2729		return -EINVAL;
2730
2731	state = drv->state + uport->line;
2732	port = &state->port;
2733
2734	mutex_lock(&port_mutex);
2735	mutex_lock(&port->mutex);
2736	if (state->uart_port) {
2737		ret = -EINVAL;
2738		goto out;
2739	}
2740
2741	/* Link the port to the driver state table and vice versa */
2742	atomic_set(&state->refcount, 1);
2743	init_waitqueue_head(&state->remove_wait);
2744	state->uart_port = uport;
2745	uport->state = state;
2746
2747	state->pm_state = UART_PM_STATE_UNDEFINED;
 
2748	uport->cons = drv->cons;
2749	uport->minor = drv->tty_driver->minor_start + uport->line;
2750	uport->name = kasprintf(GFP_KERNEL, "%s%d", drv->dev_name,
2751				drv->tty_driver->name_base + uport->line);
2752	if (!uport->name) {
2753		ret = -ENOMEM;
2754		goto out;
2755	}
2756
2757	/*
2758	 * If this port is a console, then the spinlock is already
2759	 * initialised.
2760	 */
2761	if (!(uart_console(uport) && (uport->cons->flags & CON_ENABLED))) {
2762		spin_lock_init(&uport->lock);
2763		lockdep_set_class(&uport->lock, &port_lock_key);
2764	}
2765	if (uport->cons && uport->dev)
2766		of_console_check(uport->dev->of_node, uport->cons->name, uport->line);
2767
2768	uart_configure_port(drv, state, uport);
2769
2770	port->console = uart_console(uport);
2771
2772	num_groups = 2;
2773	if (uport->attr_group)
2774		num_groups++;
2775
2776	uport->tty_groups = kcalloc(num_groups, sizeof(*uport->tty_groups),
2777				    GFP_KERNEL);
2778	if (!uport->tty_groups) {
2779		ret = -ENOMEM;
2780		goto out;
2781	}
2782	uport->tty_groups[0] = &tty_dev_attr_group;
2783	if (uport->attr_group)
2784		uport->tty_groups[1] = uport->attr_group;
2785
2786	/*
2787	 * Register the port whether it's detected or not.  This allows
2788	 * setserial to be used to alter this port's parameters.
2789	 */
2790	tty_dev = tty_port_register_device_attr_serdev(port, drv->tty_driver,
2791			uport->line, uport->dev, port, uport->tty_groups);
2792	if (likely(!IS_ERR(tty_dev))) {
2793		device_set_wakeup_capable(tty_dev, 1);
2794	} else {
2795		dev_err(uport->dev, "Cannot register tty device on line %d\n",
2796		       uport->line);
2797	}
2798
2799	/*
2800	 * Ensure UPF_DEAD is not set.
2801	 */
2802	uport->flags &= ~UPF_DEAD;
2803
2804 out:
2805	mutex_unlock(&port->mutex);
2806	mutex_unlock(&port_mutex);
2807
2808	return ret;
2809}
2810
2811/**
2812 *	uart_remove_one_port - detach a driver defined port structure
2813 *	@drv: pointer to the uart low level driver structure for this port
2814 *	@uport: uart port structure for this port
2815 *
2816 *	This unhooks (and hangs up) the specified port structure from the
2817 *	core driver.  No further calls will be made to the low-level code
2818 *	for this port.
2819 */
2820int uart_remove_one_port(struct uart_driver *drv, struct uart_port *uport)
2821{
2822	struct uart_state *state = drv->state + uport->line;
2823	struct tty_port *port = &state->port;
2824	struct uart_port *uart_port;
2825	struct tty_struct *tty;
2826	int ret = 0;
2827
2828	BUG_ON(in_interrupt());
2829
 
 
 
 
2830	mutex_lock(&port_mutex);
2831
2832	/*
2833	 * Mark the port "dead" - this prevents any opens from
2834	 * succeeding while we shut down the port.
2835	 */
2836	mutex_lock(&port->mutex);
2837	uart_port = uart_port_check(state);
2838	if (uart_port != uport)
2839		dev_alert(uport->dev, "Removing wrong port: %p != %p\n",
2840			  uart_port, uport);
2841
2842	if (!uart_port) {
2843		mutex_unlock(&port->mutex);
2844		ret = -EINVAL;
2845		goto out;
2846	}
2847	uport->flags |= UPF_DEAD;
2848	mutex_unlock(&port->mutex);
2849
2850	/*
2851	 * Remove the devices from the tty layer
2852	 */
2853	tty_port_unregister_device(port, drv->tty_driver, uport->line);
2854
2855	tty = tty_port_tty_get(port);
2856	if (tty) {
2857		tty_vhangup(port->tty);
2858		tty_kref_put(tty);
2859	}
2860
2861	/*
2862	 * If the port is used as a console, unregister it
2863	 */
2864	if (uart_console(uport))
2865		unregister_console(uport->cons);
2866
2867	/*
2868	 * Free the port IO and memory resources, if any.
2869	 */
2870	if (uport->type != PORT_UNKNOWN && uport->ops->release_port)
2871		uport->ops->release_port(uport);
2872	kfree(uport->tty_groups);
2873	kfree(uport->name);
2874
2875	/*
2876	 * Indicate that there isn't a port here anymore.
2877	 */
2878	uport->type = PORT_UNKNOWN;
2879
2880	mutex_lock(&port->mutex);
2881	WARN_ON(atomic_dec_return(&state->refcount) < 0);
2882	wait_event(state->remove_wait, !atomic_read(&state->refcount));
2883	state->uart_port = NULL;
2884	mutex_unlock(&port->mutex);
2885out:
2886	mutex_unlock(&port_mutex);
2887
2888	return ret;
2889}
2890
2891/*
2892 *	Are the two ports equivalent?
2893 */
2894int uart_match_port(struct uart_port *port1, struct uart_port *port2)
2895{
2896	if (port1->iotype != port2->iotype)
2897		return 0;
2898
2899	switch (port1->iotype) {
2900	case UPIO_PORT:
2901		return (port1->iobase == port2->iobase);
2902	case UPIO_HUB6:
2903		return (port1->iobase == port2->iobase) &&
2904		       (port1->hub6   == port2->hub6);
2905	case UPIO_MEM:
2906	case UPIO_MEM16:
2907	case UPIO_MEM32:
2908	case UPIO_MEM32BE:
2909	case UPIO_AU:
2910	case UPIO_TSI:
2911		return (port1->mapbase == port2->mapbase);
2912	}
2913	return 0;
2914}
2915EXPORT_SYMBOL(uart_match_port);
2916
2917/**
2918 *	uart_handle_dcd_change - handle a change of carrier detect state
2919 *	@uport: uart_port structure for the open port
2920 *	@status: new carrier detect status, nonzero if active
2921 *
2922 *	Caller must hold uport->lock
2923 */
2924void uart_handle_dcd_change(struct uart_port *uport, unsigned int status)
2925{
2926	struct tty_port *port = &uport->state->port;
2927	struct tty_struct *tty = port->tty;
2928	struct tty_ldisc *ld;
2929
2930	lockdep_assert_held_once(&uport->lock);
2931
2932	if (tty) {
2933		ld = tty_ldisc_ref(tty);
2934		if (ld) {
2935			if (ld->ops->dcd_change)
2936				ld->ops->dcd_change(tty, status);
2937			tty_ldisc_deref(ld);
2938		}
2939	}
2940
2941	uport->icount.dcd++;
2942
2943	if (uart_dcd_enabled(uport)) {
2944		if (status)
2945			wake_up_interruptible(&port->open_wait);
2946		else if (tty)
2947			tty_hangup(tty);
2948	}
2949}
2950EXPORT_SYMBOL_GPL(uart_handle_dcd_change);
2951
2952/**
2953 *	uart_handle_cts_change - handle a change of clear-to-send state
2954 *	@uport: uart_port structure for the open port
2955 *	@status: new clear to send status, nonzero if active
2956 *
2957 *	Caller must hold uport->lock
2958 */
2959void uart_handle_cts_change(struct uart_port *uport, unsigned int status)
2960{
2961	lockdep_assert_held_once(&uport->lock);
 
2962
2963	uport->icount.cts++;
2964
2965	if (uart_softcts_mode(uport)) {
2966		if (uport->hw_stopped) {
2967			if (status) {
2968				uport->hw_stopped = 0;
2969				uport->ops->start_tx(uport);
2970				uart_write_wakeup(uport);
2971			}
2972		} else {
2973			if (!status) {
2974				uport->hw_stopped = 1;
2975				uport->ops->stop_tx(uport);
2976			}
2977		}
2978
2979	}
2980}
2981EXPORT_SYMBOL_GPL(uart_handle_cts_change);
2982
2983/**
2984 * uart_insert_char - push a char to the uart layer
2985 *
2986 * User is responsible to call tty_flip_buffer_push when they are done with
2987 * insertion.
2988 *
2989 * @port: corresponding port
2990 * @status: state of the serial port RX buffer (LSR for 8250)
2991 * @overrun: mask of overrun bits in @status
2992 * @ch: character to push
2993 * @flag: flag for the character (see TTY_NORMAL and friends)
2994 */
2995void uart_insert_char(struct uart_port *port, unsigned int status,
2996		 unsigned int overrun, unsigned int ch, unsigned int flag)
2997{
2998	struct tty_port *tport = &port->state->port;
2999
3000	if ((status & port->ignore_status_mask & ~overrun) == 0)
3001		if (tty_insert_flip_char(tport, ch, flag) == 0)
3002			++port->icount.buf_overrun;
3003
3004	/*
3005	 * Overrun is special.  Since it's reported immediately,
3006	 * it doesn't affect the current character.
3007	 */
3008	if (status & ~port->ignore_status_mask & overrun)
3009		if (tty_insert_flip_char(tport, 0, TTY_OVERRUN) == 0)
3010			++port->icount.buf_overrun;
3011}
3012EXPORT_SYMBOL_GPL(uart_insert_char);
3013
3014EXPORT_SYMBOL(uart_write_wakeup);
3015EXPORT_SYMBOL(uart_register_driver);
3016EXPORT_SYMBOL(uart_unregister_driver);
3017EXPORT_SYMBOL(uart_suspend_port);
3018EXPORT_SYMBOL(uart_resume_port);
3019EXPORT_SYMBOL(uart_add_one_port);
3020EXPORT_SYMBOL(uart_remove_one_port);
3021
3022/**
3023 * uart_get_rs485_mode() - retrieve rs485 properties for given uart
3024 * @dev: uart device
3025 * @rs485conf: output parameter
3026 *
3027 * This function implements the device tree binding described in
3028 * Documentation/devicetree/bindings/serial/rs485.txt.
3029 */
3030void uart_get_rs485_mode(struct device *dev, struct serial_rs485 *rs485conf)
3031{
3032	u32 rs485_delay[2];
3033	int ret;
3034
3035	ret = device_property_read_u32_array(dev, "rs485-rts-delay",
3036					     rs485_delay, 2);
3037	if (!ret) {
3038		rs485conf->delay_rts_before_send = rs485_delay[0];
3039		rs485conf->delay_rts_after_send = rs485_delay[1];
3040	} else {
3041		rs485conf->delay_rts_before_send = 0;
3042		rs485conf->delay_rts_after_send = 0;
3043	}
3044
3045	/*
3046	 * Clear full-duplex and enabled flags, set RTS polarity to active high
3047	 * to get to a defined state with the following properties:
3048	 */
3049	rs485conf->flags &= ~(SER_RS485_RX_DURING_TX | SER_RS485_ENABLED |
3050			      SER_RS485_RTS_AFTER_SEND);
3051	rs485conf->flags |= SER_RS485_RTS_ON_SEND;
3052
3053	if (device_property_read_bool(dev, "rs485-rx-during-tx"))
3054		rs485conf->flags |= SER_RS485_RX_DURING_TX;
3055
3056	if (device_property_read_bool(dev, "linux,rs485-enabled-at-boot-time"))
3057		rs485conf->flags |= SER_RS485_ENABLED;
3058
3059	if (device_property_read_bool(dev, "rs485-rts-active-low")) {
3060		rs485conf->flags &= ~SER_RS485_RTS_ON_SEND;
3061		rs485conf->flags |= SER_RS485_RTS_AFTER_SEND;
3062	}
3063}
3064EXPORT_SYMBOL_GPL(uart_get_rs485_mode);
3065
3066MODULE_DESCRIPTION("Serial driver core");
3067MODULE_LICENSE("GPL");