Eric Lee / smarc-ti-linux-kernel | Embedian Git Server

Commit bbbce516bb497404315c1d0a1b13a04038347d3d

Authored by Linus Torvalds 2015-03-09 03:25:40 +0800

Exists in ti-lsk-linux-4.1.y and in 10 other branches

Merge tag 'tty-4.0-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty

Pull tty/serial fixes from Greg KH:
 "Here are some tty and serial driver fixes for 4.0-rc3.

  Along with the atime fix that you know about, here are some other
  serial driver bugfixes as well.  Most notable is a wait_until_sent
  bugfix that was traced back to being around since before 2.6.12 that
  Johan has fixed up.

  All have been in linux-next successfully"

* tag 'tty-4.0-rc3' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/tty:
  TTY: fix tty_wait_until_sent maximum timeout
  TTY: fix tty_wait_until_sent on 64-bit machines
  USB: serial: fix infinite wait_until_sent timeout
  TTY: bfin_jtag_comm: remove incorrect wait_until_sent operation
  net: irda: fix wait_until_sent poll timeout
  serial: uapi: Declare all userspace-visible io types
  serial: core: Fix iotype userspace breakage
  serial: sprd: Fix missing spin_unlock in sprd_handle_irq()
  console: Fix console name size mismatch
  tty: fix up atime/mtime mess, take four
  serial: 8250_dw: Fix get_mctrl behaviour
  serial:8250:8250_pci: delete unneeded quirk entries
  serial:8250:8250_pci: fix redundant entry report for WCH_CH352_2S
  Change email address for 8250_pci
  serial: 8250: Revert "tty: serial: 8250_core: read only RX if there is something in the FIFO"
  Revert "tty/serial: of_serial: add DT alias ID handling"

Showing 15 changed files Inline Diff

Documentation/devicetree/bindings/serial/snps-dw-apb-uart.txt
drivers/tty/bfin_jtag_comm.c
drivers/tty/serial/8250/8250_core.c
drivers/tty/serial/8250/8250_dw.c
drivers/tty/serial/8250/8250_pci.c
drivers/tty/serial/of_serial.c
drivers/tty/serial/sprd_serial.c
drivers/tty/tty_io.c
drivers/tty/tty_ioctl.c
drivers/usb/serial/generic.c
include/linux/serial_core.h
include/uapi/linux/serial.h
kernel/printk/console_cmdline.h
kernel/printk/printk.c
net/irda/ircomm/ircomm_tty.c

Documentation/devicetree/bindings/serial/snps-dw-apb-uart.txt

Diff comments View file @ bbbce51

 * Synopsys DesignWare ABP UART
 Required properties:
 - compatible : "snps,dw-apb-uart"
 - reg : offset and length of the register set for the device.
 - interrupts : should contain uart interrupt.
 Clock handling:
 The clock rate of the input clock needs to be supplied by one of
 - clock-frequency : the input clock frequency for the UART.
 - clocks : phandle to the input clock
 The supplying peripheral clock can also be handled, needing a second property
 - clock-names: tuple listing input clock names.
 	Required elements: "baudclk", "apb_pclk"
 Optional properties:
 - resets : phandle to the parent reset controller.
 - reg-shift : quantity to shift the register offsets by.  If this property is
   not present then the register offsets are not shifted.
 - reg-io-width : the size (in bytes) of the IO accesses that should be
   performed on the device.  If this property is not present then single byte
   accesses are used.
+- dcd-override : Override the DCD modem status signal. This signal will always
+  be reported as active instead of being obtained from the modem status
+  register. Define this if your serial port does not use this pin.
+- dsr-override : Override the DTS modem status signal. This signal will always
+  be reported as active instead of being obtained from the modem status
+  register. Define this if your serial port does not use this pin.
+- cts-override : Override the CTS modem status signal. This signal will always
+  be reported as active instead of being obtained from the modem status
+  register. Define this if your serial port does not use this pin.
+- ri-override : Override the RI modem status signal. This signal will always be
+  reported as inactive instead of being obtained from the modem status register.
+  Define this if your serial port does not use this pin.
 Example:
 	uart@80230000 {
 		compatible = "snps,dw-apb-uart";
 		reg = <0x80230000 0x100>;
 		clock-frequency = <3686400>;
 		interrupts = <10>;
 		reg-shift = <2>;
 		reg-io-width = <4>;
+		dcd-override;
+		dsr-override;
+		cts-override;
+		ri-override;
 	};
 Example with one clock:
 	uart@80230000 {
 		compatible = "snps,dw-apb-uart";
 		reg = <0x80230000 0x100>;
 		clocks = <&baudclk>;
 		interrupts = <10>;
 		reg-shift = <2>;
 		reg-io-width = <4>;
 	};
 Example with two clocks:
 	uart@80230000 {
 		compatible = "snps,dw-apb-uart";
 		reg = <0x80230000 0x100>;
 		clocks = <&baudclk>, <&apb_pclk>;
 		clock-names = "baudclk", "apb_pclk";
 		interrupts = <10>;
 		reg-shift = <2>;
 		reg-io-width = <4>;
 	};

drivers/tty/bfin_jtag_comm.c

Diff comments View file @ bbbce51

 /*
  * TTY over Blackfin JTAG Communication
  *
  * Copyright 2008-2009 Analog Devices Inc.
  *
  * Enter bugs at http://blackfin.uclinux.org/
  *
  * Licensed under the GPL-2 or later.
  */
 #define DRV_NAME "bfin-jtag-comm"
 #define DEV_NAME "ttyBFJC"
 #define pr_fmt(fmt) DRV_NAME ": " fmt
 #include <linux/circ_buf.h>
 #include <linux/console.h>
 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/kernel.h>
 #include <linux/kthread.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
 #include <linux/atomic.h>
 #define pr_init(fmt, args...) ({ static const __initconst char __fmt[] = fmt; printk(__fmt, ## args); })
 /* See the Debug/Emulation chapter in the HRM */
 #define EMUDOF   0x00000001	/* EMUDAT_OUT full & valid */
 #define EMUDIF   0x00000002	/* EMUDAT_IN full & valid */
 #define EMUDOOVF 0x00000004	/* EMUDAT_OUT overflow */
 #define EMUDIOVF 0x00000008	/* EMUDAT_IN overflow */
 static inline uint32_t bfin_write_emudat(uint32_t emudat)
 {
 	__asm__ __volatile__("emudat = %0;" : : "d"(emudat));
 	return emudat;
 }
 static inline uint32_t bfin_read_emudat(void)
 {
 	uint32_t emudat;
 	__asm__ __volatile__("%0 = emudat;" : "=d"(emudat));
 	return emudat;
 }
 static inline uint32_t bfin_write_emudat_chars(char a, char b, char c, char d)
 {
 	return bfin_write_emudat((a << 0) | (b << 8) | (c << 16) | (d << 24));
 }
 #define CIRC_SIZE 2048	/* see comment in tty_io.c:do_tty_write() */
 #define CIRC_MASK (CIRC_SIZE - 1)
 #define circ_empty(circ)     ((circ)->head == (circ)->tail)
 #define circ_free(circ)      CIRC_SPACE((circ)->head, (circ)->tail, CIRC_SIZE)
 #define circ_cnt(circ)       CIRC_CNT((circ)->head, (circ)->tail, CIRC_SIZE)
 #define circ_byte(circ, idx) ((circ)->buf[(idx) & CIRC_MASK])
 static struct tty_driver *bfin_jc_driver;
 static struct task_struct *bfin_jc_kthread;
 static struct tty_port port;
 static volatile struct circ_buf bfin_jc_write_buf;
 static int
 bfin_jc_emudat_manager(void *arg)
 {
 	uint32_t inbound_len = 0, outbound_len = 0;
 	while (!kthread_should_stop()) {
 		struct tty_struct *tty = tty_port_tty_get(&port);
 		/* no one left to give data to, so sleep */
 		if (tty == NULL && circ_empty(&bfin_jc_write_buf)) {
 			pr_debug("waiting for readers\n");
 			__set_current_state(TASK_UNINTERRUPTIBLE);
 			schedule();
 			continue;
 		}
 		/* no data available, so just chill */
 		if (!(bfin_read_DBGSTAT() & EMUDIF) && circ_empty(&bfin_jc_write_buf)) {
 			pr_debug("waiting for data (in_len = %i) (circ: %i %i)\n",
 				inbound_len, bfin_jc_write_buf.tail, bfin_jc_write_buf.head);
 			tty_kref_put(tty);
 			if (inbound_len)
 				schedule();
 			else
 				schedule_timeout_interruptible(HZ);
 			continue;
 		}
 		/* if incoming data is ready, eat it */
 		if (bfin_read_DBGSTAT() & EMUDIF) {
 			uint32_t emudat = bfin_read_emudat();
 			if (inbound_len == 0) {
 				pr_debug("incoming length: 0x%08x\n", emudat);
 				inbound_len = emudat;
 			} else {
 				size_t num_chars = (4 <= inbound_len ? 4 : inbound_len);
 				pr_debug("  incoming data: 0x%08x (pushing %zu)\n", emudat, num_chars);
 				inbound_len -= num_chars;
 				tty_insert_flip_string(&port, (unsigned char *)&emudat, num_chars);
 				tty_flip_buffer_push(&port);
 			}
 		}
 		/* if outgoing data is ready, post it */
 		if (!(bfin_read_DBGSTAT() & EMUDOF) && !circ_empty(&bfin_jc_write_buf)) {
 			if (outbound_len == 0) {
 				outbound_len = circ_cnt(&bfin_jc_write_buf);
 				bfin_write_emudat(outbound_len);
 				pr_debug("outgoing length: 0x%08x\n", outbound_len);
 			} else {
 				int tail = bfin_jc_write_buf.tail;
 				size_t ate = (4 <= outbound_len ? 4 : outbound_len);
 				uint32_t emudat =
 				bfin_write_emudat_chars(
 					circ_byte(&bfin_jc_write_buf, tail + 0),
 					circ_byte(&bfin_jc_write_buf, tail + 1),
 					circ_byte(&bfin_jc_write_buf, tail + 2),
 					circ_byte(&bfin_jc_write_buf, tail + 3)
 				);
 				bfin_jc_write_buf.tail += ate;
 				outbound_len -= ate;
 				if (tty)
 					tty_wakeup(tty);
 				pr_debug("  outgoing data: 0x%08x (pushing %zu)\n", emudat, ate);
 			}
 		}
 		tty_kref_put(tty);
 	}
 	__set_current_state(TASK_RUNNING);
 	return 0;
 }
 static int
 bfin_jc_open(struct tty_struct *tty, struct file *filp)
 {
 	unsigned long flags;
 	spin_lock_irqsave(&port.lock, flags);
 	port.count++;
 	spin_unlock_irqrestore(&port.lock, flags);
 	tty_port_tty_set(&port, tty);
 	wake_up_process(bfin_jc_kthread);
 	return 0;
 }
 static void
 bfin_jc_close(struct tty_struct *tty, struct file *filp)
 {
 	unsigned long flags;
 	bool last;
 	spin_lock_irqsave(&port.lock, flags);
 	last = --port.count == 0;
 	spin_unlock_irqrestore(&port.lock, flags);
 	if (last)
 		tty_port_tty_set(&port, NULL);
 	wake_up_process(bfin_jc_kthread);
 }
 /* XXX: we dont handle the put_char() case where we must handle count = 1 */
 static int
 bfin_jc_circ_write(const unsigned char *buf, int count)
 {
 	int i;
 	count = min(count, circ_free(&bfin_jc_write_buf));
 	pr_debug("going to write chunk of %i bytes\n", count);
 	for (i = 0; i < count; ++i)
 		circ_byte(&bfin_jc_write_buf, bfin_jc_write_buf.head + i) = buf[i];
 	bfin_jc_write_buf.head += i;
 	return i;
 }
 #ifndef CONFIG_BFIN_JTAG_COMM_CONSOLE
 # define console_lock()
 # define console_unlock()
 #endif
 static int
 bfin_jc_write(struct tty_struct *tty, const unsigned char *buf, int count)
 {
 	int i;
 	console_lock();
 	i = bfin_jc_circ_write(buf, count);
 	console_unlock();
 	wake_up_process(bfin_jc_kthread);
 	return i;
 }
 static void
 bfin_jc_flush_chars(struct tty_struct *tty)
 {
 	wake_up_process(bfin_jc_kthread);
 }
 static int
 bfin_jc_write_room(struct tty_struct *tty)
 {
 	return circ_free(&bfin_jc_write_buf);
 }
 static int
 bfin_jc_chars_in_buffer(struct tty_struct *tty)
 {
 	return circ_cnt(&bfin_jc_write_buf);
 }
-static void
-bfin_jc_wait_until_sent(struct tty_struct *tty, int timeout)
-{
-	unsigned long expire = jiffies + timeout;
-	while (!circ_empty(&bfin_jc_write_buf)) {
-		if (signal_pending(current))
-			break;
-		if (time_after(jiffies, expire))
-			break;
-	}
-}
 static const struct tty_operations bfin_jc_ops = {
 	.open            = bfin_jc_open,
 	.close           = bfin_jc_close,
 	.write           = bfin_jc_write,
 	/*.put_char        = bfin_jc_put_char,*/
 	.flush_chars     = bfin_jc_flush_chars,
 	.write_room      = bfin_jc_write_room,
 	.chars_in_buffer = bfin_jc_chars_in_buffer,
-	.wait_until_sent = bfin_jc_wait_until_sent,
 };
 static int __init bfin_jc_init(void)
 {
 	int ret;
 	bfin_jc_kthread = kthread_create(bfin_jc_emudat_manager, NULL, DRV_NAME);
 	if (IS_ERR(bfin_jc_kthread))
 		return PTR_ERR(bfin_jc_kthread);
 	ret = -ENOMEM;
 	bfin_jc_write_buf.head = bfin_jc_write_buf.tail = 0;
 	bfin_jc_write_buf.buf = kmalloc(CIRC_SIZE, GFP_KERNEL);
 	if (!bfin_jc_write_buf.buf)
 		goto err_buf;
 	bfin_jc_driver = alloc_tty_driver(1);
 	if (!bfin_jc_driver)
 		goto err_driver;
 	tty_port_init(&port);
 	bfin_jc_driver->driver_name  = DRV_NAME;
 	bfin_jc_driver->name         = DEV_NAME;
 	bfin_jc_driver->type         = TTY_DRIVER_TYPE_SERIAL;
 	bfin_jc_driver->subtype      = SERIAL_TYPE_NORMAL;
 	bfin_jc_driver->init_termios = tty_std_termios;
 	tty_set_operations(bfin_jc_driver, &bfin_jc_ops);
 	tty_port_link_device(&port, bfin_jc_driver, 0);
 	ret = tty_register_driver(bfin_jc_driver);
 	if (ret)
 		goto err;
 	pr_init(KERN_INFO DRV_NAME ": initialized\n");
 	return 0;
  err:
 	tty_port_destroy(&port);
 	put_tty_driver(bfin_jc_driver);
  err_driver:
 	kfree(bfin_jc_write_buf.buf);
  err_buf:
 	kthread_stop(bfin_jc_kthread);
 	return ret;
 }
 module_init(bfin_jc_init);
 static void __exit bfin_jc_exit(void)
 {
 	kthread_stop(bfin_jc_kthread);
 	kfree(bfin_jc_write_buf.buf);
 	tty_unregister_driver(bfin_jc_driver);
 	put_tty_driver(bfin_jc_driver);
 	tty_port_destroy(&port);
 }
 module_exit(bfin_jc_exit);
 #if defined(CONFIG_BFIN_JTAG_COMM_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
 static void
 bfin_jc_straight_buffer_write(const char *buf, unsigned count)
 {
 	unsigned ate = 0;
 	while (bfin_read_DBGSTAT() & EMUDOF)
 		continue;
 	bfin_write_emudat(count);
 	while (ate < count) {
 		while (bfin_read_DBGSTAT() & EMUDOF)
 			continue;
 		bfin_write_emudat_chars(buf[ate], buf[ate+1], buf[ate+2], buf[ate+3]);
 		ate += 4;
 	}
 }
 #endif
 #ifdef CONFIG_BFIN_JTAG_COMM_CONSOLE
 static void
 bfin_jc_console_write(struct console *co, const char *buf, unsigned count)
 {
 	if (bfin_jc_kthread == NULL)
 		bfin_jc_straight_buffer_write(buf, count);
 	else
 		bfin_jc_circ_write(buf, count);
 }
 static struct tty_driver *
 bfin_jc_console_device(struct console *co, int *index)
 {
 	*index = co->index;
 	return bfin_jc_driver;
 }
 static struct console bfin_jc_console = {
 	.name    = DEV_NAME,
 	.write   = bfin_jc_console_write,
 	.device  = bfin_jc_console_device,
 	.flags   = CON_ANYTIME | CON_PRINTBUFFER,
 	.index   = -1,
 };
 static int __init bfin_jc_console_init(void)
 {
 	register_console(&bfin_jc_console);
 	return 0;
 }
 console_initcall(bfin_jc_console_init);
 #endif
 #ifdef CONFIG_EARLY_PRINTK
 static void __init
 bfin_jc_early_write(struct console *co, const char *buf, unsigned int count)
 {
 	bfin_jc_straight_buffer_write(buf, count);
 }
 static struct console bfin_jc_early_console __initdata = {
 	.name   = "early_BFJC",
 	.write   = bfin_jc_early_write,
 	.flags   = CON_ANYTIME | CON_PRINTBUFFER,
 	.index   = -1,
 };
 struct console * __init
 bfin_jc_early_init(unsigned int port, unsigned int cflag)
 {
 	return &bfin_jc_early_console;
 }
 #endif
 MODULE_AUTHOR("Mike Frysinger <vapier@gentoo.org>");
 MODULE_DESCRIPTION("TTY over Blackfin JTAG Communication");
 MODULE_LICENSE("GPL");

drivers/tty/serial/8250/8250_core.c

Diff comments View file @ bbbce51

 /*
  *  Driver for 8250/16550-type serial ports
  *
  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
  *
  *  Copyright (C) 2001 Russell King.
  *
  * 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.
  *
  * A note about mapbase / membase
  *
  *  mapbase is the physical address of the IO port.
  *  membase is an 'ioremapped' cookie.
  */
 #if defined(CONFIG_SERIAL_8250_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
 #define SUPPORT_SYSRQ
 #endif
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/console.h>
 #include <linux/sysrq.h>
 #include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/tty.h>
 #include <linux/ratelimit.h>
 #include <linux/tty_flip.h>
 #include <linux/serial_core.h>
 #include <linux/serial.h>
 #include <linux/serial_8250.h>
 #include <linux/nmi.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
 #include <linux/uaccess.h>
 #include <linux/pm_runtime.h>
 #ifdef CONFIG_SPARC
 #include <linux/sunserialcore.h>
 #endif
 #include <asm/io.h>
 #include <asm/irq.h>
 #include "8250.h"
 /*
  * Configuration:
  *   share_irqs - whether we pass IRQF_SHARED to request_irq().  This option
  *                is unsafe when used on edge-triggered interrupts.
  */
 static unsigned int share_irqs = SERIAL8250_SHARE_IRQS;
 static unsigned int nr_uarts = CONFIG_SERIAL_8250_RUNTIME_UARTS;
 static struct uart_driver serial8250_reg;
 static int serial_index(struct uart_port *port)
 {
 	return (serial8250_reg.minor - 64) + port->line;
 }
 static unsigned int skip_txen_test; /* force skip of txen test at init time */
 /*
  * Debugging.
  */
 #if 0
 #define DEBUG_AUTOCONF(fmt...)	printk(fmt)
 #else
 #define DEBUG_AUTOCONF(fmt...)	do { } while (0)
 #endif
 #if 0
 #define DEBUG_INTR(fmt...)	printk(fmt)
 #else
 #define DEBUG_INTR(fmt...)	do { } while (0)
 #endif
 #define PASS_LIMIT	512
 #define BOTH_EMPTY 	(UART_LSR_TEMT | UART_LSR_THRE)
 #ifdef CONFIG_SERIAL_8250_DETECT_IRQ
 #define CONFIG_SERIAL_DETECT_IRQ 1
 #endif
 #ifdef CONFIG_SERIAL_8250_MANY_PORTS
 #define CONFIG_SERIAL_MANY_PORTS 1
 #endif
 /*
  * HUB6 is always on.  This will be removed once the header
  * files have been cleaned.
  */
 #define CONFIG_HUB6 1
 #include <asm/serial.h>
 /*
  * SERIAL_PORT_DFNS tells us about built-in ports that have no
  * standard enumeration mechanism.   Platforms that can find all
  * serial ports via mechanisms like ACPI or PCI need not supply it.
  */
 #ifndef SERIAL_PORT_DFNS
 #define SERIAL_PORT_DFNS
 #endif
 static const struct old_serial_port old_serial_port[] = {
 	SERIAL_PORT_DFNS /* defined in asm/serial.h */
 };
 #define UART_NR	CONFIG_SERIAL_8250_NR_UARTS
 #ifdef CONFIG_SERIAL_8250_RSA
 #define PORT_RSA_MAX 4
 static unsigned long probe_rsa[PORT_RSA_MAX];
 static unsigned int probe_rsa_count;
 #endif /* CONFIG_SERIAL_8250_RSA  */
 struct irq_info {
 	struct			hlist_node node;
 	int			irq;
 	spinlock_t		lock;	/* Protects list not the hash */
 	struct list_head	*head;
 };
 #define NR_IRQ_HASH		32	/* Can be adjusted later */
 static struct hlist_head irq_lists[NR_IRQ_HASH];
 static DEFINE_MUTEX(hash_mutex);	/* Used to walk the hash */
 /*
  * Here we define the default xmit fifo size used for each type of UART.
  */
 static const struct serial8250_config uart_config[] = {
 	[PORT_UNKNOWN] = {
 		.name		= "unknown",
 		.fifo_size	= 1,
 		.tx_loadsz	= 1,
 	},
 	[PORT_8250] = {
 		.name		= "8250",
 		.fifo_size	= 1,
 		.tx_loadsz	= 1,
 	},
 	[PORT_16450] = {
 		.name		= "16450",
 		.fifo_size	= 1,
 		.tx_loadsz	= 1,
 	},
 	[PORT_16550] = {
 		.name		= "16550",
 		.fifo_size	= 1,
 		.tx_loadsz	= 1,
 	},
 	[PORT_16550A] = {
 		.name		= "16550A",
 		.fifo_size	= 16,
 		.tx_loadsz	= 16,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 		.rxtrig_bytes	= {1, 4, 8, 14},
 		.flags		= UART_CAP_FIFO,
 	},
 	[PORT_CIRRUS] = {
 		.name		= "Cirrus",
 		.fifo_size	= 1,
 		.tx_loadsz	= 1,
 	},
 	[PORT_16650] = {
 		.name		= "ST16650",
 		.fifo_size	= 1,
 		.tx_loadsz	= 1,
 		.flags		= UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 	},
 	[PORT_16650V2] = {
 		.name		= "ST16650V2",
 		.fifo_size	= 32,
 		.tx_loadsz	= 16,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
 				  UART_FCR_T_TRIG_00,
 		.rxtrig_bytes	= {8, 16, 24, 28},
 		.flags		= UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 	},
 	[PORT_16750] = {
 		.name		= "TI16750",
 		.fifo_size	= 64,
 		.tx_loadsz	= 64,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10 |
 				  UART_FCR7_64BYTE,
 		.rxtrig_bytes	= {1, 16, 32, 56},
 		.flags		= UART_CAP_FIFO | UART_CAP_SLEEP | UART_CAP_AFE,
 	},
 	[PORT_STARTECH] = {
 		.name		= "Startech",
 		.fifo_size	= 1,
 		.tx_loadsz	= 1,
 	},
 	[PORT_16C950] = {
 		.name		= "16C950/954",
 		.fifo_size	= 128,
 		.tx_loadsz	= 128,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 		/* UART_CAP_EFR breaks billionon CF bluetooth card. */
 		.flags		= UART_CAP_FIFO | UART_CAP_SLEEP,
 	},
 	[PORT_16654] = {
 		.name		= "ST16654",
 		.fifo_size	= 64,
 		.tx_loadsz	= 32,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
 				  UART_FCR_T_TRIG_10,
 		.rxtrig_bytes	= {8, 16, 56, 60},
 		.flags		= UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 	},
 	[PORT_16850] = {
 		.name		= "XR16850",
 		.fifo_size	= 128,
 		.tx_loadsz	= 128,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 		.flags		= UART_CAP_FIFO | UART_CAP_EFR | UART_CAP_SLEEP,
 	},
 	[PORT_RSA] = {
 		.name		= "RSA",
 		.fifo_size	= 2048,
 		.tx_loadsz	= 2048,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_11,
 		.flags		= UART_CAP_FIFO,
 	},
 	[PORT_NS16550A] = {
 		.name		= "NS16550A",
 		.fifo_size	= 16,
 		.tx_loadsz	= 16,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 		.flags		= UART_CAP_FIFO | UART_NATSEMI,
 	},
 	[PORT_XSCALE] = {
 		.name		= "XScale",
 		.fifo_size	= 32,
 		.tx_loadsz	= 32,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 		.flags		= UART_CAP_FIFO | UART_CAP_UUE | UART_CAP_RTOIE,
 	},
 	[PORT_OCTEON] = {
 		.name		= "OCTEON",
 		.fifo_size	= 64,
 		.tx_loadsz	= 64,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 		.flags		= UART_CAP_FIFO,
 	},
 	[PORT_AR7] = {
 		.name		= "AR7",
 		.fifo_size	= 16,
 		.tx_loadsz	= 16,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_00,
 		.flags		= UART_CAP_FIFO | UART_CAP_AFE,
 	},
 	[PORT_U6_16550A] = {
 		.name		= "U6_16550A",
 		.fifo_size	= 64,
 		.tx_loadsz	= 64,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 		.flags		= UART_CAP_FIFO | UART_CAP_AFE,
 	},
 	[PORT_TEGRA] = {
 		.name		= "Tegra",
 		.fifo_size	= 32,
 		.tx_loadsz	= 8,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_01 |
 				  UART_FCR_T_TRIG_01,
 		.rxtrig_bytes	= {1, 4, 8, 14},
 		.flags		= UART_CAP_FIFO | UART_CAP_RTOIE,
 	},
 	[PORT_XR17D15X] = {
 		.name		= "XR17D15X",
 		.fifo_size	= 64,
 		.tx_loadsz	= 64,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 		.flags		= UART_CAP_FIFO | UART_CAP_AFE | UART_CAP_EFR |
 				  UART_CAP_SLEEP,
 	},
 	[PORT_XR17V35X] = {
 		.name		= "XR17V35X",
 		.fifo_size	= 256,
 		.tx_loadsz	= 256,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_11 |
 				  UART_FCR_T_TRIG_11,
 		.flags		= UART_CAP_FIFO | UART_CAP_AFE | UART_CAP_EFR |
 				  UART_CAP_SLEEP,
 	},
 	[PORT_LPC3220] = {
 		.name		= "LPC3220",
 		.fifo_size	= 64,
 		.tx_loadsz	= 32,
 		.fcr		= UART_FCR_DMA_SELECT | UART_FCR_ENABLE_FIFO |
 				  UART_FCR_R_TRIG_00 | UART_FCR_T_TRIG_00,
 		.flags		= UART_CAP_FIFO,
 	},
 	[PORT_BRCM_TRUMANAGE] = {
 		.name		= "TruManage",
 		.fifo_size	= 1,
 		.tx_loadsz	= 1024,
 		.flags		= UART_CAP_HFIFO,
 	},
 	[PORT_8250_CIR] = {
 		.name		= "CIR port"
 	},
 	[PORT_ALTR_16550_F32] = {
 		.name		= "Altera 16550 FIFO32",
 		.fifo_size	= 32,
 		.tx_loadsz	= 32,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 		.flags		= UART_CAP_FIFO | UART_CAP_AFE,
 	},
 	[PORT_ALTR_16550_F64] = {
 		.name		= "Altera 16550 FIFO64",
 		.fifo_size	= 64,
 		.tx_loadsz	= 64,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 		.flags		= UART_CAP_FIFO | UART_CAP_AFE,
 	},
 	[PORT_ALTR_16550_F128] = {
 		.name		= "Altera 16550 FIFO128",
 		.fifo_size	= 128,
 		.tx_loadsz	= 128,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10,
 		.flags		= UART_CAP_FIFO | UART_CAP_AFE,
 	},
 /* tx_loadsz is set to 63-bytes instead of 64-bytes to implement
 workaround of errata A-008006 which states that tx_loadsz should  be
 configured less than Maximum supported fifo bytes */
 	[PORT_16550A_FSL64] = {
 		.name		= "16550A_FSL64",
 		.fifo_size	= 64,
 		.tx_loadsz	= 63,
 		.fcr		= UART_FCR_ENABLE_FIFO | UART_FCR_R_TRIG_10 |
 				  UART_FCR7_64BYTE,
 		.flags		= UART_CAP_FIFO,
 	},
 };
 /* Uart divisor latch read */
 static int default_serial_dl_read(struct uart_8250_port *up)
 {
 	return serial_in(up, UART_DLL) | serial_in(up, UART_DLM) << 8;
 }
 /* Uart divisor latch write */
 static void default_serial_dl_write(struct uart_8250_port *up, int value)
 {
 	serial_out(up, UART_DLL, value & 0xff);
 	serial_out(up, UART_DLM, value >> 8 & 0xff);
 }
 #if defined(CONFIG_MIPS_ALCHEMY) || defined(CONFIG_SERIAL_8250_RT288X)
 /* Au1x00/RT288x UART hardware has a weird register layout */
 static const u8 au_io_in_map[] = {
 	[UART_RX]  = 0,
 	[UART_IER] = 2,
 	[UART_IIR] = 3,
 	[UART_LCR] = 5,
 	[UART_MCR] = 6,
 	[UART_LSR] = 7,
 	[UART_MSR] = 8,
 };
 static const u8 au_io_out_map[] = {
 	[UART_TX]  = 1,
 	[UART_IER] = 2,
 	[UART_FCR] = 4,
 	[UART_LCR] = 5,
 	[UART_MCR] = 6,
 };
 static unsigned int au_serial_in(struct uart_port *p, int offset)
 {
 	offset = au_io_in_map[offset] << p->regshift;
 	return __raw_readl(p->membase + offset);
 }
 static void au_serial_out(struct uart_port *p, int offset, int value)
 {
 	offset = au_io_out_map[offset] << p->regshift;
 	__raw_writel(value, p->membase + offset);
 }
 /* Au1x00 haven't got a standard divisor latch */
 static int au_serial_dl_read(struct uart_8250_port *up)
 {
 	return __raw_readl(up->port.membase + 0x28);
 }
 static void au_serial_dl_write(struct uart_8250_port *up, int value)
 {
 	__raw_writel(value, up->port.membase + 0x28);
 }
 #endif
 static unsigned int hub6_serial_in(struct uart_port *p, int offset)
 {
 	offset = offset << p->regshift;
 	outb(p->hub6 - 1 + offset, p->iobase);
 	return inb(p->iobase + 1);
 }
 static void hub6_serial_out(struct uart_port *p, int offset, int value)
 {
 	offset = offset << p->regshift;
 	outb(p->hub6 - 1 + offset, p->iobase);
 	outb(value, p->iobase + 1);
 }
 static unsigned int mem_serial_in(struct uart_port *p, int offset)
 {
 	offset = offset << p->regshift;
 	return readb(p->membase + offset);
 }
 static void mem_serial_out(struct uart_port *p, int offset, int value)
 {
 	offset = offset << p->regshift;
 	writeb(value, p->membase + offset);
 }
 static void mem32_serial_out(struct uart_port *p, int offset, int value)
 {
 	offset = offset << p->regshift;
 	writel(value, p->membase + offset);
 }
 static unsigned int mem32_serial_in(struct uart_port *p, int offset)
 {
 	offset = offset << p->regshift;
 	return readl(p->membase + offset);
 }
 static unsigned int io_serial_in(struct uart_port *p, int offset)
 {
 	offset = offset << p->regshift;
 	return inb(p->iobase + offset);
 }
 static void io_serial_out(struct uart_port *p, int offset, int value)
 {
 	offset = offset << p->regshift;
 	outb(value, p->iobase + offset);
 }
 static int serial8250_default_handle_irq(struct uart_port *port);
 static int exar_handle_irq(struct uart_port *port);
 static void set_io_from_upio(struct uart_port *p)
 {
 	struct uart_8250_port *up = up_to_u8250p(p);
 	up->dl_read = default_serial_dl_read;
 	up->dl_write = default_serial_dl_write;
 	switch (p->iotype) {
 	case UPIO_HUB6:
 		p->serial_in = hub6_serial_in;
 		p->serial_out = hub6_serial_out;
 		break;
 	case UPIO_MEM:
 		p->serial_in = mem_serial_in;
 		p->serial_out = mem_serial_out;
 		break;
 	case UPIO_MEM32:
 		p->serial_in = mem32_serial_in;
 		p->serial_out = mem32_serial_out;
 		break;
 #if defined(CONFIG_MIPS_ALCHEMY) || defined(CONFIG_SERIAL_8250_RT288X)
 	case UPIO_AU:
 		p->serial_in = au_serial_in;
 		p->serial_out = au_serial_out;
 		up->dl_read = au_serial_dl_read;
 		up->dl_write = au_serial_dl_write;
 		break;
 #endif
 	default:
 		p->serial_in = io_serial_in;
 		p->serial_out = io_serial_out;
 		break;
 	}
 	/* Remember loaded iotype */
 	up->cur_iotype = p->iotype;
 	p->handle_irq = serial8250_default_handle_irq;
 }
 static void
 serial_port_out_sync(struct uart_port *p, int offset, int value)
 {
 	switch (p->iotype) {
 	case UPIO_MEM:
 	case UPIO_MEM32:
 	case UPIO_AU:
 		p->serial_out(p, offset, value);
 		p->serial_in(p, UART_LCR);	/* safe, no side-effects */
 		break;
 	default:
 		p->serial_out(p, offset, value);
 	}
 }
 /*
  * For the 16C950
  */
 static void serial_icr_write(struct uart_8250_port *up, int offset, int value)
 {
 	serial_out(up, UART_SCR, offset);
 	serial_out(up, UART_ICR, value);
 }
 static unsigned int serial_icr_read(struct uart_8250_port *up, int offset)
 {
 	unsigned int value;
 	serial_icr_write(up, UART_ACR, up->acr | UART_ACR_ICRRD);
 	serial_out(up, UART_SCR, offset);
 	value = serial_in(up, UART_ICR);
 	serial_icr_write(up, UART_ACR, up->acr);
 	return value;
 }
 /*
  * FIFO support.
  */
 static void serial8250_clear_fifos(struct uart_8250_port *p)
 {
 	if (p->capabilities & UART_CAP_FIFO) {
 		serial_out(p, UART_FCR, UART_FCR_ENABLE_FIFO);
 		serial_out(p, UART_FCR, UART_FCR_ENABLE_FIFO |
 			       UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 		serial_out(p, UART_FCR, 0);
 	}
 }
 void serial8250_clear_and_reinit_fifos(struct uart_8250_port *p)
 {
 	serial8250_clear_fifos(p);
 	serial_out(p, UART_FCR, p->fcr);
 }
 EXPORT_SYMBOL_GPL(serial8250_clear_and_reinit_fifos);
 void serial8250_rpm_get(struct uart_8250_port *p)
 {
 	if (!(p->capabilities & UART_CAP_RPM))
 		return;
 	pm_runtime_get_sync(p->port.dev);
 }
 EXPORT_SYMBOL_GPL(serial8250_rpm_get);
 void serial8250_rpm_put(struct uart_8250_port *p)
 {
 	if (!(p->capabilities & UART_CAP_RPM))
 		return;
 	pm_runtime_mark_last_busy(p->port.dev);
 	pm_runtime_put_autosuspend(p->port.dev);
 }
 EXPORT_SYMBOL_GPL(serial8250_rpm_put);
 /*
  * These two wrappers ensure that enable_runtime_pm_tx() can be called more than
  * once and disable_runtime_pm_tx() will still disable RPM because the fifo is
  * empty and the HW can idle again.
  */
 static void serial8250_rpm_get_tx(struct uart_8250_port *p)
 {
 	unsigned char rpm_active;
 	if (!(p->capabilities & UART_CAP_RPM))
 		return;
 	rpm_active = xchg(&p->rpm_tx_active, 1);
 	if (rpm_active)
 		return;
 	pm_runtime_get_sync(p->port.dev);
 }
 static void serial8250_rpm_put_tx(struct uart_8250_port *p)
 {
 	unsigned char rpm_active;
 	if (!(p->capabilities & UART_CAP_RPM))
 		return;
 	rpm_active = xchg(&p->rpm_tx_active, 0);
 	if (!rpm_active)
 		return;
 	pm_runtime_mark_last_busy(p->port.dev);
 	pm_runtime_put_autosuspend(p->port.dev);
 }
 /*
  * IER sleep support.  UARTs which have EFRs need the "extended
  * capability" bit enabled.  Note that on XR16C850s, we need to
  * reset LCR to write to IER.
  */
 static void serial8250_set_sleep(struct uart_8250_port *p, int sleep)
 {
 	unsigned char lcr = 0, efr = 0;
 	/*
 	 * Exar UARTs have a SLEEP register that enables or disables
 	 * each UART to enter sleep mode separately.  On the XR17V35x the
 	 * register is accessible to each UART at the UART_EXAR_SLEEP
 	 * offset but the UART channel may only write to the corresponding
 	 * bit.
 	 */
 	serial8250_rpm_get(p);
 	if ((p->port.type == PORT_XR17V35X) ||
 	   (p->port.type == PORT_XR17D15X)) {
 		serial_out(p, UART_EXAR_SLEEP, sleep ? 0xff : 0);
 		goto out;
 	}
 	if (p->capabilities & UART_CAP_SLEEP) {
 		if (p->capabilities & UART_CAP_EFR) {
 			lcr = serial_in(p, UART_LCR);
 			efr = serial_in(p, UART_EFR);
 			serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B);
 			serial_out(p, UART_EFR, UART_EFR_ECB);
 			serial_out(p, UART_LCR, 0);
 		}
 		serial_out(p, UART_IER, sleep ? UART_IERX_SLEEP : 0);
 		if (p->capabilities & UART_CAP_EFR) {
 			serial_out(p, UART_LCR, UART_LCR_CONF_MODE_B);
 			serial_out(p, UART_EFR, efr);
 			serial_out(p, UART_LCR, lcr);
 		}
 	}
 out:
 	serial8250_rpm_put(p);
 }
 #ifdef CONFIG_SERIAL_8250_RSA
 /*
  * Attempts to turn on the RSA FIFO.  Returns zero on failure.
  * We set the port uart clock rate if we succeed.
  */
 static int __enable_rsa(struct uart_8250_port *up)
 {
 	unsigned char mode;
 	int result;
 	mode = serial_in(up, UART_RSA_MSR);
 	result = mode & UART_RSA_MSR_FIFO;
 	if (!result) {
 		serial_out(up, UART_RSA_MSR, mode | UART_RSA_MSR_FIFO);
 		mode = serial_in(up, UART_RSA_MSR);
 		result = mode & UART_RSA_MSR_FIFO;
 	}
 	if (result)
 		up->port.uartclk = SERIAL_RSA_BAUD_BASE * 16;
 	return result;
 }
 static void enable_rsa(struct uart_8250_port *up)
 {
 	if (up->port.type == PORT_RSA) {
 		if (up->port.uartclk != SERIAL_RSA_BAUD_BASE * 16) {
 			spin_lock_irq(&up->port.lock);
 			__enable_rsa(up);
 			spin_unlock_irq(&up->port.lock);
 		}
 		if (up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16)
 			serial_out(up, UART_RSA_FRR, 0);
 	}
 }
 /*
  * Attempts to turn off the RSA FIFO.  Returns zero on failure.
  * It is unknown why interrupts were disabled in here.  However,
  * the caller is expected to preserve this behaviour by grabbing
  * the spinlock before calling this function.
  */
 static void disable_rsa(struct uart_8250_port *up)
 {
 	unsigned char mode;
 	int result;
 	if (up->port.type == PORT_RSA &&
 	    up->port.uartclk == SERIAL_RSA_BAUD_BASE * 16) {
 		spin_lock_irq(&up->port.lock);
 		mode = serial_in(up, UART_RSA_MSR);
 		result = !(mode & UART_RSA_MSR_FIFO);
 		if (!result) {
 			serial_out(up, UART_RSA_MSR, mode & ~UART_RSA_MSR_FIFO);
 			mode = serial_in(up, UART_RSA_MSR);
 			result = !(mode & UART_RSA_MSR_FIFO);
 		}
 		if (result)
 			up->port.uartclk = SERIAL_RSA_BAUD_BASE_LO * 16;
 		spin_unlock_irq(&up->port.lock);
 	}
 }
 #endif /* CONFIG_SERIAL_8250_RSA */
 /*
  * This is a quickie test to see how big the FIFO is.
  * It doesn't work at all the time, more's the pity.
  */
 static int size_fifo(struct uart_8250_port *up)
 {
 	unsigned char old_fcr, old_mcr, old_lcr;
 	unsigned short old_dl;
 	int count;
 	old_lcr = serial_in(up, UART_LCR);
 	serial_out(up, UART_LCR, 0);
 	old_fcr = serial_in(up, UART_FCR);
 	old_mcr = serial_in(up, UART_MCR);
 	serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO |
 		    UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 	serial_out(up, UART_MCR, UART_MCR_LOOP);
 	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
 	old_dl = serial_dl_read(up);
 	serial_dl_write(up, 0x0001);
 	serial_out(up, UART_LCR, 0x03);
 	for (count = 0; count < 256; count++)
 		serial_out(up, UART_TX, count);
 	mdelay(20);/* FIXME - schedule_timeout */
 	for (count = 0; (serial_in(up, UART_LSR) & UART_LSR_DR) &&
 	     (count < 256); count++)
 		serial_in(up, UART_RX);
 	serial_out(up, UART_FCR, old_fcr);
 	serial_out(up, UART_MCR, old_mcr);
 	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
 	serial_dl_write(up, old_dl);
 	serial_out(up, UART_LCR, old_lcr);
 	return count;
 }
 /*
  * Read UART ID using the divisor method - set DLL and DLM to zero
  * and the revision will be in DLL and device type in DLM.  We
  * preserve the device state across this.
  */
 static unsigned int autoconfig_read_divisor_id(struct uart_8250_port *p)
 {
 	unsigned char old_dll, old_dlm, old_lcr;
 	unsigned int id;
 	old_lcr = serial_in(p, UART_LCR);
 	serial_out(p, UART_LCR, UART_LCR_CONF_MODE_A);
 	old_dll = serial_in(p, UART_DLL);
 	old_dlm = serial_in(p, UART_DLM);
 	serial_out(p, UART_DLL, 0);
 	serial_out(p, UART_DLM, 0);
 	id = serial_in(p, UART_DLL) | serial_in(p, UART_DLM) << 8;
 	serial_out(p, UART_DLL, old_dll);
 	serial_out(p, UART_DLM, old_dlm);
 	serial_out(p, UART_LCR, old_lcr);
 	return id;
 }
 /*
  * This is a helper routine to autodetect StarTech/Exar/Oxsemi UART's.
  * When this function is called we know it is at least a StarTech
  * 16650 V2, but it might be one of several StarTech UARTs, or one of
  * its clones.  (We treat the broken original StarTech 16650 V1 as a
  * 16550, and why not?  Startech doesn't seem to even acknowledge its
  * existence.)
  *
  * What evil have men's minds wrought...
  */
 static void autoconfig_has_efr(struct uart_8250_port *up)
 {
 	unsigned int id1, id2, id3, rev;
 	/*
 	 * Everything with an EFR has SLEEP
 	 */
 	up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP;
 	/*
 	 * First we check to see if it's an Oxford Semiconductor UART.
 	 *
 	 * If we have to do this here because some non-National
 	 * Semiconductor clone chips lock up if you try writing to the
 	 * LSR register (which serial_icr_read does)
 	 */
 	/*
 	 * Check for Oxford Semiconductor 16C950.
 	 *
 	 * EFR [4] must be set else this test fails.
 	 *
 	 * This shouldn't be necessary, but Mike Hudson (Exoray@isys.ca)
 	 * claims that it's needed for 952 dual UART's (which are not
 	 * recommended for new designs).
 	 */
 	up->acr = 0;
 	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
 	serial_out(up, UART_EFR, UART_EFR_ECB);
 	serial_out(up, UART_LCR, 0x00);
 	id1 = serial_icr_read(up, UART_ID1);
 	id2 = serial_icr_read(up, UART_ID2);
 	id3 = serial_icr_read(up, UART_ID3);
 	rev = serial_icr_read(up, UART_REV);
 	DEBUG_AUTOCONF("950id=%02x:%02x:%02x:%02x ", id1, id2, id3, rev);
 	if (id1 == 0x16 && id2 == 0xC9 &&
 	    (id3 == 0x50 || id3 == 0x52 || id3 == 0x54)) {
 		up->port.type = PORT_16C950;
 		/*
 		 * Enable work around for the Oxford Semiconductor 952 rev B
 		 * chip which causes it to seriously miscalculate baud rates
 		 * when DLL is 0.
 		 */
 		if (id3 == 0x52 && rev == 0x01)
 			up->bugs |= UART_BUG_QUOT;
 		return;
 	}
 	/*
 	 * We check for a XR16C850 by setting DLL and DLM to 0, and then
 	 * reading back DLL and DLM.  The chip type depends on the DLM
 	 * value read back:
 	 *  0x10 - XR16C850 and the DLL contains the chip revision.
 	 *  0x12 - XR16C2850.
 	 *  0x14 - XR16C854.
 	 */
 	id1 = autoconfig_read_divisor_id(up);
 	DEBUG_AUTOCONF("850id=%04x ", id1);
 	id2 = id1 >> 8;
 	if (id2 == 0x10 || id2 == 0x12 || id2 == 0x14) {
 		up->port.type = PORT_16850;
 		return;
 	}
 	/*
 	 * It wasn't an XR16C850.
 	 *
 	 * We distinguish between the '654 and the '650 by counting
 	 * how many bytes are in the FIFO.  I'm using this for now,
 	 * since that's the technique that was sent to me in the
 	 * serial driver update, but I'm not convinced this works.
 	 * I've had problems doing this in the past.  -TYT
 	 */
 	if (size_fifo(up) == 64)
 		up->port.type = PORT_16654;
 	else
 		up->port.type = PORT_16650V2;
 }
 /*
  * We detected a chip without a FIFO.  Only two fall into
  * this category - the original 8250 and the 16450.  The
  * 16450 has a scratch register (accessible with LCR=0)
  */
 static void autoconfig_8250(struct uart_8250_port *up)
 {
 	unsigned char scratch, status1, status2;
 	up->port.type = PORT_8250;
 	scratch = serial_in(up, UART_SCR);
 	serial_out(up, UART_SCR, 0xa5);
 	status1 = serial_in(up, UART_SCR);
 	serial_out(up, UART_SCR, 0x5a);
 	status2 = serial_in(up, UART_SCR);
 	serial_out(up, UART_SCR, scratch);
 	if (status1 == 0xa5 && status2 == 0x5a)
 		up->port.type = PORT_16450;
 }
 static int broken_efr(struct uart_8250_port *up)
 {
 	/*
 	 * Exar ST16C2550 "A2" devices incorrectly detect as
 	 * having an EFR, and report an ID of 0x0201.  See
 	 * http://linux.derkeiler.com/Mailing-Lists/Kernel/2004-11/4812.html
 	 */
 	if (autoconfig_read_divisor_id(up) == 0x0201 && size_fifo(up) == 16)
 		return 1;
 	return 0;
 }
 static inline int ns16550a_goto_highspeed(struct uart_8250_port *up)
 {
 	unsigned char status;
 	status = serial_in(up, 0x04); /* EXCR2 */
 #define PRESL(x) ((x) & 0x30)
 	if (PRESL(status) == 0x10) {
 		/* already in high speed mode */
 		return 0;
 	} else {
 		status &= ~0xB0; /* Disable LOCK, mask out PRESL[01] */
 		status |= 0x10;  /* 1.625 divisor for baud_base --> 921600 */
 		serial_out(up, 0x04, status);
 	}
 	return 1;
 }
 /*
  * We know that the chip has FIFOs.  Does it have an EFR?  The
  * EFR is located in the same register position as the IIR and
  * we know the top two bits of the IIR are currently set.  The
  * EFR should contain zero.  Try to read the EFR.
  */
 static void autoconfig_16550a(struct uart_8250_port *up)
 {
 	unsigned char status1, status2;
 	unsigned int iersave;
 	up->port.type = PORT_16550A;
 	up->capabilities |= UART_CAP_FIFO;
 	/*
 	 * XR17V35x UARTs have an extra divisor register, DLD
 	 * that gets enabled with when DLAB is set which will
 	 * cause the device to incorrectly match and assign
 	 * port type to PORT_16650.  The EFR for this UART is
 	 * found at offset 0x09. Instead check the Deice ID (DVID)
 	 * register for a 2, 4 or 8 port UART.
 	 */
 	if (up->port.flags & UPF_EXAR_EFR) {
 		status1 = serial_in(up, UART_EXAR_DVID);
 		if (status1 == 0x82 || status1 == 0x84 || status1 == 0x88) {
 			DEBUG_AUTOCONF("Exar XR17V35x ");
 			up->port.type = PORT_XR17V35X;
 			up->capabilities |= UART_CAP_AFE | UART_CAP_EFR |
 						UART_CAP_SLEEP;
 			return;
 		}
 	}
 	/*
 	 * Check for presence of the EFR when DLAB is set.
 	 * Only ST16C650V1 UARTs pass this test.
 	 */
 	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
 	if (serial_in(up, UART_EFR) == 0) {
 		serial_out(up, UART_EFR, 0xA8);
 		if (serial_in(up, UART_EFR) != 0) {
 			DEBUG_AUTOCONF("EFRv1 ");
 			up->port.type = PORT_16650;
 			up->capabilities |= UART_CAP_EFR | UART_CAP_SLEEP;
 		} else {
 			serial_out(up, UART_LCR, 0);
 			serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO |
 				   UART_FCR7_64BYTE);
 			status1 = serial_in(up, UART_IIR) >> 5;
 			serial_out(up, UART_FCR, 0);
 			serial_out(up, UART_LCR, 0);
 			if (status1 == 7)
 				up->port.type = PORT_16550A_FSL64;
 			else
 				DEBUG_AUTOCONF("Motorola 8xxx DUART ");
 		}
 		serial_out(up, UART_EFR, 0);
 		return;
 	}
 	/*
 	 * Maybe it requires 0xbf to be written to the LCR.
 	 * (other ST16C650V2 UARTs, TI16C752A, etc)
 	 */
 	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
 	if (serial_in(up, UART_EFR) == 0 && !broken_efr(up)) {
 		DEBUG_AUTOCONF("EFRv2 ");
 		autoconfig_has_efr(up);
 		return;
 	}
 	/*
 	 * Check for a National Semiconductor SuperIO chip.
 	 * Attempt to switch to bank 2, read the value of the LOOP bit
 	 * from EXCR1. Switch back to bank 0, change it in MCR. Then
 	 * switch back to bank 2, read it from EXCR1 again and check
 	 * it's changed. If so, set baud_base in EXCR2 to 921600. -- dwmw2
 	 */
 	serial_out(up, UART_LCR, 0);
 	status1 = serial_in(up, UART_MCR);
 	serial_out(up, UART_LCR, 0xE0);
 	status2 = serial_in(up, 0x02); /* EXCR1 */
 	if (!((status2 ^ status1) & UART_MCR_LOOP)) {
 		serial_out(up, UART_LCR, 0);
 		serial_out(up, UART_MCR, status1 ^ UART_MCR_LOOP);
 		serial_out(up, UART_LCR, 0xE0);
 		status2 = serial_in(up, 0x02); /* EXCR1 */
 		serial_out(up, UART_LCR, 0);
 		serial_out(up, UART_MCR, status1);
 		if ((status2 ^ status1) & UART_MCR_LOOP) {
 			unsigned short quot;
 			serial_out(up, UART_LCR, 0xE0);
 			quot = serial_dl_read(up);
 			quot <<= 3;
 			if (ns16550a_goto_highspeed(up))
 				serial_dl_write(up, quot);
 			serial_out(up, UART_LCR, 0);
 			up->port.uartclk = 921600*16;
 			up->port.type = PORT_NS16550A;
 			up->capabilities |= UART_NATSEMI;
 			return;
 		}
 	}
 	/*
 	 * No EFR.  Try to detect a TI16750, which only sets bit 5 of
 	 * the IIR when 64 byte FIFO mode is enabled when DLAB is set.
 	 * Try setting it with and without DLAB set.  Cheap clones
 	 * set bit 5 without DLAB set.
 	 */
 	serial_out(up, UART_LCR, 0);
 	serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
 	status1 = serial_in(up, UART_IIR) >> 5;
 	serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
 	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_A);
 	serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE);
 	status2 = serial_in(up, UART_IIR) >> 5;
 	serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
 	serial_out(up, UART_LCR, 0);
 	DEBUG_AUTOCONF("iir1=%d iir2=%d ", status1, status2);
 	if (status1 == 6 && status2 == 7) {
 		up->port.type = PORT_16750;
 		up->capabilities |= UART_CAP_AFE | UART_CAP_SLEEP;
 		return;
 	}
 	/*
 	 * Try writing and reading the UART_IER_UUE bit (b6).
 	 * If it works, this is probably one of the Xscale platform's
 	 * internal UARTs.
 	 * We're going to explicitly set the UUE bit to 0 before
 	 * trying to write and read a 1 just to make sure it's not
 	 * already a 1 and maybe locked there before we even start start.
 	 */
 	iersave = serial_in(up, UART_IER);
 	serial_out(up, UART_IER, iersave & ~UART_IER_UUE);
 	if (!(serial_in(up, UART_IER) & UART_IER_UUE)) {
 		/*
 		 * OK it's in a known zero state, try writing and reading
 		 * without disturbing the current state of the other bits.
 		 */
 		serial_out(up, UART_IER, iersave | UART_IER_UUE);
 		if (serial_in(up, UART_IER) & UART_IER_UUE) {
 			/*
 			 * It's an Xscale.
 			 * We'll leave the UART_IER_UUE bit set to 1 (enabled).
 			 */
 			DEBUG_AUTOCONF("Xscale ");
 			up->port.type = PORT_XSCALE;
 			up->capabilities |= UART_CAP_UUE | UART_CAP_RTOIE;
 			return;
 		}
 	} else {
 		/*
 		 * If we got here we couldn't force the IER_UUE bit to 0.
 		 * Log it and continue.
 		 */
 		DEBUG_AUTOCONF("Couldn't force IER_UUE to 0 ");
 	}
 	serial_out(up, UART_IER, iersave);
 	/*
 	 * Exar uarts have EFR in a weird location
 	 */
 	if (up->port.flags & UPF_EXAR_EFR) {
 		DEBUG_AUTOCONF("Exar XR17D15x ");
 		up->port.type = PORT_XR17D15X;
 		up->capabilities |= UART_CAP_AFE | UART_CAP_EFR |
 				    UART_CAP_SLEEP;
 		return;
 	}
 	/*
 	 * We distinguish between 16550A and U6 16550A by counting
 	 * how many bytes are in the FIFO.
 	 */
 	if (up->port.type == PORT_16550A && size_fifo(up) == 64) {
 		up->port.type = PORT_U6_16550A;
 		up->capabilities |= UART_CAP_AFE;
 	}
 }
 /*
  * This routine is called by rs_init() to initialize a specific serial
  * port.  It determines what type of UART chip this serial port is
  * using: 8250, 16450, 16550, 16550A.  The important question is
  * whether or not this UART is a 16550A or not, since this will
  * determine whether or not we can use its FIFO features or not.
  */
 static void autoconfig(struct uart_8250_port *up, unsigned int probeflags)
 {
 	unsigned char status1, scratch, scratch2, scratch3;
 	unsigned char save_lcr, save_mcr;
 	struct uart_port *port = &up->port;
 	unsigned long flags;
 	unsigned int old_capabilities;
 	if (!port->iobase && !port->mapbase && !port->membase)
 		return;
 	DEBUG_AUTOCONF("ttyS%d: autoconf (0x%04lx, 0x%p): ",
 		       serial_index(port), port->iobase, port->membase);
 	/*
 	 * We really do need global IRQs disabled here - we're going to
 	 * be frobbing the chips IRQ enable register to see if it exists.
 	 */
 	spin_lock_irqsave(&port->lock, flags);
 	up->capabilities = 0;
 	up->bugs = 0;
 	if (!(port->flags & UPF_BUGGY_UART)) {
 		/*
 		 * Do a simple existence test first; if we fail this,
 		 * there's no point trying anything else.
 		 *
 		 * 0x80 is used as a nonsense port to prevent against
 		 * false positives due to ISA bus float.  The
 		 * assumption is that 0x80 is a non-existent port;
 		 * which should be safe since include/asm/io.h also
 		 * makes this assumption.
 		 *
 		 * Note: this is safe as long as MCR bit 4 is clear
 		 * and the device is in "PC" mode.
 		 */
 		scratch = serial_in(up, UART_IER);
 		serial_out(up, UART_IER, 0);
 #ifdef __i386__
 		outb(0xff, 0x080);
 #endif
 		/*
 		 * Mask out IER[7:4] bits for test as some UARTs (e.g. TL
 		 * 16C754B) allow only to modify them if an EFR bit is set.
 		 */
 		scratch2 = serial_in(up, UART_IER) & 0x0f;
 		serial_out(up, UART_IER, 0x0F);
 #ifdef __i386__
 		outb(0, 0x080);
 #endif
 		scratch3 = serial_in(up, UART_IER) & 0x0f;
 		serial_out(up, UART_IER, scratch);
 		if (scratch2 != 0 || scratch3 != 0x0F) {
 			/*
 			 * We failed; there's nothing here
 			 */
 			spin_unlock_irqrestore(&port->lock, flags);
 			DEBUG_AUTOCONF("IER test failed (%02x, %02x) ",
 				       scratch2, scratch3);
 			goto out;
 		}
 	}
 	save_mcr = serial_in(up, UART_MCR);
 	save_lcr = serial_in(up, UART_LCR);
 	/*
 	 * Check to see if a UART is really there.  Certain broken
 	 * internal modems based on the Rockwell chipset fail this
 	 * test, because they apparently don't implement the loopback
 	 * test mode.  So this test is skipped on the COM 1 through
 	 * COM 4 ports.  This *should* be safe, since no board
 	 * manufacturer would be stupid enough to design a board
 	 * that conflicts with COM 1-4 --- we hope!
 	 */
 	if (!(port->flags & UPF_SKIP_TEST)) {
 		serial_out(up, UART_MCR, UART_MCR_LOOP | 0x0A);
 		status1 = serial_in(up, UART_MSR) & 0xF0;
 		serial_out(up, UART_MCR, save_mcr);
 		if (status1 != 0x90) {
 			spin_unlock_irqrestore(&port->lock, flags);
 			DEBUG_AUTOCONF("LOOP test failed (%02x) ",
 				       status1);
 			goto out;
 		}
 	}
 	/*
 	 * We're pretty sure there's a port here.  Lets find out what
 	 * type of port it is.  The IIR top two bits allows us to find
 	 * out if it's 8250 or 16450, 16550, 16550A or later.  This
 	 * determines what we test for next.
 	 *
 	 * We also initialise the EFR (if any) to zero for later.  The
 	 * EFR occupies the same register location as the FCR and IIR.
 	 */
 	serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
 	serial_out(up, UART_EFR, 0);
 	serial_out(up, UART_LCR, 0);
 	serial_out(up, UART_FCR, UART_FCR_ENABLE_FIFO);
 	scratch = serial_in(up, UART_IIR) >> 6;
 	switch (scratch) {
 	case 0:
 		autoconfig_8250(up);
 		break;
 	case 1:
 		port->type = PORT_UNKNOWN;
 		break;
 	case 2:
 		port->type = PORT_16550;
 		break;
 	case 3:
 		autoconfig_16550a(up);
 		break;
 	}
 #ifdef CONFIG_SERIAL_8250_RSA
 	/*
 	 * Only probe for RSA ports if we got the region.
 	 */
 	if (port->type == PORT_16550A && probeflags & PROBE_RSA) {
 		int i;
 		for (i = 0 ; i < probe_rsa_count; ++i) {
 			if (probe_rsa[i] == port->iobase && __enable_rsa(up)) {
 				port->type = PORT_RSA;
 				break;
 			}
 		}
 	}
 #endif
 	serial_out(up, UART_LCR, save_lcr);
 	port->fifosize = uart_config[up->port.type].fifo_size;
 	old_capabilities = up->capabilities;
 	up->capabilities = uart_config[port->type].flags;
 	up->tx_loadsz = uart_config[port->type].tx_loadsz;
 	if (port->type == PORT_UNKNOWN)
 		goto out_lock;
 	/*
 	 * Reset the UART.
 	 */
 #ifdef CONFIG_SERIAL_8250_RSA
 	if (port->type == PORT_RSA)
 		serial_out(up, UART_RSA_FRR, 0);
 #endif
 	serial_out(up, UART_MCR, save_mcr);
 	serial8250_clear_fifos(up);
 	serial_in(up, UART_RX);
 	if (up->capabilities & UART_CAP_UUE)
 		serial_out(up, UART_IER, UART_IER_UUE);
 	else
 		serial_out(up, UART_IER, 0);
 out_lock:
 	spin_unlock_irqrestore(&port->lock, flags);
 	if (up->capabilities != old_capabilities) {
 		printk(KERN_WARNING
 		       "ttyS%d: detected caps %08x should be %08x\n",
 		       serial_index(port), old_capabilities,
 		       up->capabilities);
 	}
 out:
 	DEBUG_AUTOCONF("iir=%d ", scratch);
 	DEBUG_AUTOCONF("type=%s\n", uart_config[port->type].name);
 }
 static void autoconfig_irq(struct uart_8250_port *up)
 {
 	struct uart_port *port = &up->port;
 	unsigned char save_mcr, save_ier;
 	unsigned char save_ICP = 0;
 	unsigned int ICP = 0;
 	unsigned long irqs;
 	int irq;
 	if (port->flags & UPF_FOURPORT) {
 		ICP = (port->iobase & 0xfe0) | 0x1f;
 		save_ICP = inb_p(ICP);
 		outb_p(0x80, ICP);
 		inb_p(ICP);
 	}
 	/* forget possible initially masked and pending IRQ */
 	probe_irq_off(probe_irq_on());
 	save_mcr = serial_in(up, UART_MCR);
 	save_ier = serial_in(up, UART_IER);
 	serial_out(up, UART_MCR, UART_MCR_OUT1 | UART_MCR_OUT2);
 	irqs = probe_irq_on();
 	serial_out(up, UART_MCR, 0);
 	udelay(10);
 	if (port->flags & UPF_FOURPORT) {
 		serial_out(up, UART_MCR,
 			    UART_MCR_DTR | UART_MCR_RTS);
 	} else {
 		serial_out(up, UART_MCR,
 			    UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2);
 	}
 	serial_out(up, UART_IER, 0x0f);	/* enable all intrs */
 	serial_in(up, UART_LSR);
 	serial_in(up, UART_RX);
 	serial_in(up, UART_IIR);
 	serial_in(up, UART_MSR);
 	serial_out(up, UART_TX, 0xFF);
 	udelay(20);
 	irq = probe_irq_off(irqs);
 	serial_out(up, UART_MCR, save_mcr);
 	serial_out(up, UART_IER, save_ier);
 	if (port->flags & UPF_FOURPORT)
 		outb_p(save_ICP, ICP);
 	port->irq = (irq > 0) ? irq : 0;
 }
 static inline void __stop_tx(struct uart_8250_port *p)
 {
 	if (p->ier & UART_IER_THRI) {
 		p->ier &= ~UART_IER_THRI;
 		serial_out(p, UART_IER, p->ier);
 		serial8250_rpm_put_tx(p);
 	}
 }
 static void serial8250_stop_tx(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	serial8250_rpm_get(up);
 	__stop_tx(up);
 	/*
 	 * We really want to stop the transmitter from sending.
 	 */
 	if (port->type == PORT_16C950) {
 		up->acr |= UART_ACR_TXDIS;
 		serial_icr_write(up, UART_ACR, up->acr);
 	}
 	serial8250_rpm_put(up);
 }
 static void serial8250_start_tx(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	serial8250_rpm_get_tx(up);
 	if (up->dma && !up->dma->tx_dma(up))
 		return;
 	if (!(up->ier & UART_IER_THRI)) {
 		up->ier |= UART_IER_THRI;
 		serial_port_out(port, UART_IER, up->ier);
 		if (up->bugs & UART_BUG_TXEN) {
 			unsigned char lsr;
 			lsr = serial_in(up, UART_LSR);
 			up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
 			if (lsr & UART_LSR_THRE)
 				serial8250_tx_chars(up);
 		}
 	}
 	/*
 	 * Re-enable the transmitter if we disabled it.
 	 */
 	if (port->type == PORT_16C950 && up->acr & UART_ACR_TXDIS) {
 		up->acr &= ~UART_ACR_TXDIS;
 		serial_icr_write(up, UART_ACR, up->acr);
 	}
 }
 static void serial8250_throttle(struct uart_port *port)
 {
 	port->throttle(port);
 }
 static void serial8250_unthrottle(struct uart_port *port)
 {
 	port->unthrottle(port);
 }
 static void serial8250_stop_rx(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	serial8250_rpm_get(up);
 	up->ier &= ~(UART_IER_RLSI | UART_IER_RDI);
 	up->port.read_status_mask &= ~UART_LSR_DR;
 	serial_port_out(port, UART_IER, up->ier);
 	serial8250_rpm_put(up);
 }
 static void serial8250_disable_ms(struct uart_port *port)
 {
 	struct uart_8250_port *up =
 		container_of(port, struct uart_8250_port, port);
 	/* no MSR capabilities */
 	if (up->bugs & UART_BUG_NOMSR)
 		return;
 	up->ier &= ~UART_IER_MSI;
 	serial_port_out(port, UART_IER, up->ier);
 }
 static void serial8250_enable_ms(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	/* no MSR capabilities */
 	if (up->bugs & UART_BUG_NOMSR)
 		return;
 	up->ier |= UART_IER_MSI;
 	serial8250_rpm_get(up);
 	serial_port_out(port, UART_IER, up->ier);
 	serial8250_rpm_put(up);
 }
 /*
  * serial8250_rx_chars: processes according to the passed in LSR
  * value, and returns the remaining LSR bits not handled
  * by this Rx routine.
  */
 unsigned char
 serial8250_rx_chars(struct uart_8250_port *up, unsigned char lsr)
 {
 	struct uart_port *port = &up->port;
 	unsigned char ch;
 	int max_count = 256;
 	char flag;
 	do {
 		if (likely(lsr & UART_LSR_DR))
 			ch = serial_in(up, UART_RX);
 		else
 			/*
 			 * Intel 82571 has a Serial Over Lan device that will
 			 * set UART_LSR_BI without setting UART_LSR_DR when
 			 * it receives a break. To avoid reading from the
 			 * receive buffer without UART_LSR_DR bit set, we
 			 * just force the read character to be 0
 			 */
 			ch = 0;
 		flag = TTY_NORMAL;
 		port->icount.rx++;
 		lsr |= up->lsr_saved_flags;
 		up->lsr_saved_flags = 0;
 		if (unlikely(lsr & UART_LSR_BRK_ERROR_BITS)) {
 			if (lsr & UART_LSR_BI) {
 				lsr &= ~(UART_LSR_FE | UART_LSR_PE);
 				port->icount.brk++;
 				/*
 				 * We do the SysRQ and SAK checking
 				 * here because otherwise the break
 				 * may get masked by ignore_status_mask
 				 * or read_status_mask.
 				 */
 				if (uart_handle_break(port))
 					goto ignore_char;
 			} else if (lsr & UART_LSR_PE)
 				port->icount.parity++;
 			else if (lsr & UART_LSR_FE)
 				port->icount.frame++;
 			if (lsr & UART_LSR_OE)
 				port->icount.overrun++;
 			/*
 			 * Mask off conditions which should be ignored.
 			 */
 			lsr &= port->read_status_mask;
 			if (lsr & UART_LSR_BI) {
 				DEBUG_INTR("handling break....");
 				flag = TTY_BREAK;
 			} else if (lsr & UART_LSR_PE)
 				flag = TTY_PARITY;
 			else if (lsr & UART_LSR_FE)
 				flag = TTY_FRAME;
 		}
 		if (uart_handle_sysrq_char(port, ch))
 			goto ignore_char;
 		uart_insert_char(port, lsr, UART_LSR_OE, ch, flag);
 ignore_char:
 		lsr = serial_in(up, UART_LSR);
 	} while ((lsr & (UART_LSR_DR | UART_LSR_BI)) && (--max_count > 0));
 	spin_unlock(&port->lock);
 	tty_flip_buffer_push(&port->state->port);
 	spin_lock(&port->lock);
 	return lsr;
 }
 EXPORT_SYMBOL_GPL(serial8250_rx_chars);
 void serial8250_tx_chars(struct uart_8250_port *up)
 {
 	struct uart_port *port = &up->port;
 	struct circ_buf *xmit = &port->state->xmit;
 	int count;
 	if (port->x_char) {
 		serial_out(up, UART_TX, port->x_char);
 		port->icount.tx++;
 		port->x_char = 0;
 		return;
 	}
 	if (uart_tx_stopped(port)) {
 		serial8250_stop_tx(port);
 		return;
 	}
 	if (uart_circ_empty(xmit)) {
 		__stop_tx(up);
 		return;
 	}
 	count = up->tx_loadsz;
 	do {
 		serial_out(up, UART_TX, xmit->buf[xmit->tail]);
 		xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 		port->icount.tx++;
 		if (uart_circ_empty(xmit))
 			break;
 		if (up->capabilities & UART_CAP_HFIFO) {
 			if ((serial_port_in(port, UART_LSR) & BOTH_EMPTY) !=
 			    BOTH_EMPTY)
 				break;
 		}
 	} while (--count > 0);
 	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 		uart_write_wakeup(port);
 	DEBUG_INTR("THRE...");
 	/*
 	 * With RPM enabled, we have to wait until the FIFO is empty before the
 	 * HW can go idle. So we get here once again with empty FIFO and disable
 	 * the interrupt and RPM in __stop_tx()
 	 */
 	if (uart_circ_empty(xmit) && !(up->capabilities & UART_CAP_RPM))
 		__stop_tx(up);
 }
 EXPORT_SYMBOL_GPL(serial8250_tx_chars);
 /* Caller holds uart port lock */
 unsigned int serial8250_modem_status(struct uart_8250_port *up)
 {
 	struct uart_port *port = &up->port;
 	unsigned int status = serial_in(up, UART_MSR);
 	status |= up->msr_saved_flags;
 	up->msr_saved_flags = 0;
 	if (status & UART_MSR_ANY_DELTA && up->ier & UART_IER_MSI &&
 	    port->state != NULL) {
 		if (status & UART_MSR_TERI)
 			port->icount.rng++;
 		if (status & UART_MSR_DDSR)
 			port->icount.dsr++;
 		if (status & UART_MSR_DDCD)
 			uart_handle_dcd_change(port, status & UART_MSR_DCD);
 		if (status & UART_MSR_DCTS)
 			uart_handle_cts_change(port, status & UART_MSR_CTS);
 		wake_up_interruptible(&port->state->port.delta_msr_wait);
 	}
 	return status;
 }
 EXPORT_SYMBOL_GPL(serial8250_modem_status);
 /*
  * This handles the interrupt from one port.
  */
 int serial8250_handle_irq(struct uart_port *port, unsigned int iir)
 {
 	unsigned char status;
 	unsigned long flags;
 	struct uart_8250_port *up = up_to_u8250p(port);
 	int dma_err = 0;
 	if (iir & UART_IIR_NO_INT)
 		return 0;
 	spin_lock_irqsave(&port->lock, flags);
 	status = serial_port_in(port, UART_LSR);
 	DEBUG_INTR("status = %x...", status);
 	if (status & (UART_LSR_DR | UART_LSR_BI)) {
 		if (up->dma)
 			dma_err = up->dma->rx_dma(up, iir);
 		if (!up->dma || dma_err)
 			status = serial8250_rx_chars(up, status);
 	}
 	serial8250_modem_status(up);
 	if ((!up->dma || (up->dma && up->dma->tx_err)) &&
 	    (status & UART_LSR_THRE))
 		serial8250_tx_chars(up);
 	spin_unlock_irqrestore(&port->lock, flags);
 	return 1;
 }
 EXPORT_SYMBOL_GPL(serial8250_handle_irq);
 static int serial8250_default_handle_irq(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	unsigned int iir;
 	int ret;
 	serial8250_rpm_get(up);
 	iir = serial_port_in(port, UART_IIR);
 	ret = serial8250_handle_irq(port, iir);
 	serial8250_rpm_put(up);
 	return ret;
 }
 /*
  * These Exar UARTs have an extra interrupt indicator that could
  * fire for a few unimplemented interrupts.  One of which is a
  * wakeup event when coming out of sleep.  Put this here just
  * to be on the safe side that these interrupts don't go unhandled.
  */
 static int exar_handle_irq(struct uart_port *port)
 {
 	unsigned char int0, int1, int2, int3;
 	unsigned int iir = serial_port_in(port, UART_IIR);
 	int ret;
 	ret = serial8250_handle_irq(port, iir);
 	if ((port->type == PORT_XR17V35X) ||
 	   (port->type == PORT_XR17D15X)) {
 		int0 = serial_port_in(port, 0x80);
 		int1 = serial_port_in(port, 0x81);
 		int2 = serial_port_in(port, 0x82);
 		int3 = serial_port_in(port, 0x83);
 	}
 	return ret;
 }
 /*
  * This is the serial driver's interrupt routine.
  *
  * Arjan thinks the old way was overly complex, so it got simplified.
  * Alan disagrees, saying that need the complexity to handle the weird
  * nature of ISA shared interrupts.  (This is a special exception.)
  *
  * In order to handle ISA shared interrupts properly, we need to check
  * that all ports have been serviced, and therefore the ISA interrupt
  * line has been de-asserted.
  *
  * This means we need to loop through all ports. checking that they
  * don't have an interrupt pending.
  */
 static irqreturn_t serial8250_interrupt(int irq, void *dev_id)
 {
 	struct irq_info *i = dev_id;
 	struct list_head *l, *end = NULL;
 	int pass_counter = 0, handled = 0;
 	DEBUG_INTR("serial8250_interrupt(%d)...", irq);
 	spin_lock(&i->lock);
 	l = i->head;
 	do {
 		struct uart_8250_port *up;
 		struct uart_port *port;
 		up = list_entry(l, struct uart_8250_port, list);
 		port = &up->port;
 		if (port->handle_irq(port)) {
 			handled = 1;
 			end = NULL;
 		} else if (end == NULL)
 			end = l;
 		l = l->next;
 		if (l == i->head && pass_counter++ > PASS_LIMIT) {
 			/* If we hit this, we're dead. */
 			printk_ratelimited(KERN_ERR
 				"serial8250: too much work for irq%d\n", irq);
 			break;
 		}
 	} while (l != end);
 	spin_unlock(&i->lock);
 	DEBUG_INTR("end.\n");
 	return IRQ_RETVAL(handled);
 }
 /*
  * To support ISA shared interrupts, we need to have one interrupt
  * handler that ensures that the IRQ line has been deasserted
  * before returning.  Failing to do this will result in the IRQ
  * line being stuck active, and, since ISA irqs are edge triggered,
  * no more IRQs will be seen.
  */
 static void serial_do_unlink(struct irq_info *i, struct uart_8250_port *up)
 {
 	spin_lock_irq(&i->lock);
 	if (!list_empty(i->head)) {
 		if (i->head == &up->list)
 			i->head = i->head->next;
 		list_del(&up->list);
 	} else {
 		BUG_ON(i->head != &up->list);
 		i->head = NULL;
 	}
 	spin_unlock_irq(&i->lock);
 	/* List empty so throw away the hash node */
 	if (i->head == NULL) {
 		hlist_del(&i->node);
 		kfree(i);
 	}
 }
 static int serial_link_irq_chain(struct uart_8250_port *up)
 {
 	struct hlist_head *h;
 	struct hlist_node *n;
 	struct irq_info *i;
 	int ret, irq_flags = up->port.flags & UPF_SHARE_IRQ ? IRQF_SHARED : 0;
 	mutex_lock(&hash_mutex);
 	h = &irq_lists[up->port.irq % NR_IRQ_HASH];
 	hlist_for_each(n, h) {
 		i = hlist_entry(n, struct irq_info, node);
 		if (i->irq == up->port.irq)
 			break;
 	}
 	if (n == NULL) {
 		i = kzalloc(sizeof(struct irq_info), GFP_KERNEL);
 		if (i == NULL) {
 			mutex_unlock(&hash_mutex);
 			return -ENOMEM;
 		}
 		spin_lock_init(&i->lock);
 		i->irq = up->port.irq;
 		hlist_add_head(&i->node, h);
 	}
 	mutex_unlock(&hash_mutex);
 	spin_lock_irq(&i->lock);
 	if (i->head) {
 		list_add(&up->list, i->head);
 		spin_unlock_irq(&i->lock);
 		ret = 0;
 	} else {
 		INIT_LIST_HEAD(&up->list);
 		i->head = &up->list;
 		spin_unlock_irq(&i->lock);
 		irq_flags |= up->port.irqflags;
 		ret = request_irq(up->port.irq, serial8250_interrupt,
 				  irq_flags, "serial", i);
 		if (ret < 0)
 			serial_do_unlink(i, up);
 	}
 	return ret;
 }
 static void serial_unlink_irq_chain(struct uart_8250_port *up)
 {
 	/*
 	 * yes, some broken gcc emit "warning: 'i' may be used uninitialized"
 	 * but no, we are not going to take a patch that assigns NULL below.
 	 */
 	struct irq_info *i;
 	struct hlist_node *n;
 	struct hlist_head *h;
 	mutex_lock(&hash_mutex);
 	h = &irq_lists[up->port.irq % NR_IRQ_HASH];
 	hlist_for_each(n, h) {
 		i = hlist_entry(n, struct irq_info, node);
 		if (i->irq == up->port.irq)
 			break;
 	}
 	BUG_ON(n == NULL);
 	BUG_ON(i->head == NULL);
 	if (list_empty(i->head))
 		free_irq(up->port.irq, i);
 	serial_do_unlink(i, up);
 	mutex_unlock(&hash_mutex);
 }
 /*
  * This function is used to handle ports that do not have an
  * interrupt.  This doesn't work very well for 16450's, but gives
  * barely passable results for a 16550A.  (Although at the expense
  * of much CPU overhead).
  */
 static void serial8250_timeout(unsigned long data)
 {
 	struct uart_8250_port *up = (struct uart_8250_port *)data;
 	up->port.handle_irq(&up->port);
 	mod_timer(&up->timer, jiffies + uart_poll_timeout(&up->port));
 }
 static void serial8250_backup_timeout(unsigned long data)
 {
 	struct uart_8250_port *up = (struct uart_8250_port *)data;
 	unsigned int iir, ier = 0, lsr;
 	unsigned long flags;
 	spin_lock_irqsave(&up->port.lock, flags);
 	/*
 	 * Must disable interrupts or else we risk racing with the interrupt
 	 * based handler.
 	 */
 	if (up->port.irq) {
 		ier = serial_in(up, UART_IER);
 		serial_out(up, UART_IER, 0);
 	}
 	iir = serial_in(up, UART_IIR);
 	/*
 	 * This should be a safe test for anyone who doesn't trust the
 	 * IIR bits on their UART, but it's specifically designed for
 	 * the "Diva" UART used on the management processor on many HP
 	 * ia64 and parisc boxes.
 	 */
 	lsr = serial_in(up, UART_LSR);
 	up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
 	if ((iir & UART_IIR_NO_INT) && (up->ier & UART_IER_THRI) &&
 	    (!uart_circ_empty(&up->port.state->xmit) || up->port.x_char) &&
 	    (lsr & UART_LSR_THRE)) {
 		iir &= ~(UART_IIR_ID | UART_IIR_NO_INT);
 		iir |= UART_IIR_THRI;
 	}
 	if (!(iir & UART_IIR_NO_INT))
 		serial8250_tx_chars(up);
 	if (up->port.irq)
 		serial_out(up, UART_IER, ier);
 	spin_unlock_irqrestore(&up->port.lock, flags);
 	/* Standard timer interval plus 0.2s to keep the port running */
 	mod_timer(&up->timer,
 		jiffies + uart_poll_timeout(&up->port) + HZ / 5);
 }
 static unsigned int serial8250_tx_empty(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	unsigned long flags;
 	unsigned int lsr;
 	serial8250_rpm_get(up);
 	spin_lock_irqsave(&port->lock, flags);
 	lsr = serial_port_in(port, UART_LSR);
 	up->lsr_saved_flags |= lsr & LSR_SAVE_FLAGS;
 	spin_unlock_irqrestore(&port->lock, flags);
 	serial8250_rpm_put(up);
 	return (lsr & BOTH_EMPTY) == BOTH_EMPTY ? TIOCSER_TEMT : 0;
 }
 static unsigned int serial8250_get_mctrl(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	unsigned int status;
 	unsigned int ret;
 	serial8250_rpm_get(up);
 	status = serial8250_modem_status(up);
 	serial8250_rpm_put(up);
 	ret = 0;
 	if (status & UART_MSR_DCD)
 		ret |= TIOCM_CAR;
 	if (status & UART_MSR_RI)
 		ret |= TIOCM_RNG;
 	if (status & UART_MSR_DSR)
 		ret |= TIOCM_DSR;
 	if (status & UART_MSR_CTS)
 		ret |= TIOCM_CTS;
 	return ret;
 }
 void serial8250_do_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	unsigned char mcr = 0;
 	if (mctrl & TIOCM_RTS)
 		mcr |= UART_MCR_RTS;
 	if (mctrl & TIOCM_DTR)
 		mcr |= UART_MCR_DTR;
 	if (mctrl & TIOCM_OUT1)
 		mcr |= UART_MCR_OUT1;
 	if (mctrl & TIOCM_OUT2)
 		mcr |= UART_MCR_OUT2;
 	if (mctrl & TIOCM_LOOP)
 		mcr |= UART_MCR_LOOP;
 	mcr = (mcr & up->mcr_mask) | up->mcr_force | up->mcr;
 	serial_port_out(port, UART_MCR, mcr);
 }
 EXPORT_SYMBOL_GPL(serial8250_do_set_mctrl);
 static void serial8250_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
 	if (port->set_mctrl)
 		return port->set_mctrl(port, mctrl);
 	return serial8250_do_set_mctrl(port, mctrl);
 }
 static void serial8250_break_ctl(struct uart_port *port, int break_state)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	unsigned long flags;
 	serial8250_rpm_get(up);
 	spin_lock_irqsave(&port->lock, flags);
 	if (break_state == -1)
 		up->lcr |= UART_LCR_SBC;
 	else
 		up->lcr &= ~UART_LCR_SBC;
 	serial_port_out(port, UART_LCR, up->lcr);
 	spin_unlock_irqrestore(&port->lock, flags);
 	serial8250_rpm_put(up);
 }
 /*
  *	Wait for transmitter & holding register to empty
  */
 static void wait_for_xmitr(struct uart_8250_port *up, int bits)
 {
 	unsigned int status, tmout = 10000;
 	/* Wait up to 10ms for the character(s) to be sent. */
 	for (;;) {
 		status = serial_in(up, UART_LSR);
 		up->lsr_saved_flags |= status & LSR_SAVE_FLAGS;
 		if ((status & bits) == bits)
 			break;
 		if (--tmout == 0)
 			break;
 		udelay(1);
 	}
 	/* Wait up to 1s for flow control if necessary */
 	if (up->port.flags & UPF_CONS_FLOW) {
 		unsigned int tmout;
 		for (tmout = 1000000; tmout; tmout--) {
 			unsigned int msr = serial_in(up, UART_MSR);
 			up->msr_saved_flags |= msr & MSR_SAVE_FLAGS;
 			if (msr & UART_MSR_CTS)
 				break;
 			udelay(1);
 			touch_nmi_watchdog();
 		}
 	}
 }
 #ifdef CONFIG_CONSOLE_POLL
 /*
  * Console polling routines for writing and reading from the uart while
  * in an interrupt or debug context.
  */
 static int serial8250_get_poll_char(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	unsigned char lsr;
 	int status;
 	serial8250_rpm_get(up);
 	lsr = serial_port_in(port, UART_LSR);
 	if (!(lsr & UART_LSR_DR)) {
 		status = NO_POLL_CHAR;
 		goto out;
 	}
 	status = serial_port_in(port, UART_RX);
 out:
 	serial8250_rpm_put(up);
 	return status;
 }
 static void serial8250_put_poll_char(struct uart_port *port,
 			 unsigned char c)
 {
 	unsigned int ier;
 	struct uart_8250_port *up = up_to_u8250p(port);
 	serial8250_rpm_get(up);
 	/*
 	 *	First save the IER then disable the interrupts
 	 */
 	ier = serial_port_in(port, UART_IER);
 	if (up->capabilities & UART_CAP_UUE)
 		serial_port_out(port, UART_IER, UART_IER_UUE);
 	else
 		serial_port_out(port, UART_IER, 0);
 	wait_for_xmitr(up, BOTH_EMPTY);
 	/*
 	 *	Send the character out.
 	 */
 	serial_port_out(port, UART_TX, c);
 	/*
 	 *	Finally, wait for transmitter to become empty
 	 *	and restore the IER
 	 */
 	wait_for_xmitr(up, BOTH_EMPTY);
 	serial_port_out(port, UART_IER, ier);
 	serial8250_rpm_put(up);
 }
 #endif /* CONFIG_CONSOLE_POLL */
 int serial8250_do_startup(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	unsigned long flags;
 	unsigned char lsr, iir;
 	int retval;
 	if (port->type == PORT_8250_CIR)
 		return -ENODEV;
 	if (!port->fifosize)
 		port->fifosize = uart_config[port->type].fifo_size;
 	if (!up->tx_loadsz)
 		up->tx_loadsz = uart_config[port->type].tx_loadsz;
 	if (!up->capabilities)
 		up->capabilities = uart_config[port->type].flags;
 	up->mcr = 0;
 	if (port->iotype != up->cur_iotype)
 		set_io_from_upio(port);
 	serial8250_rpm_get(up);
 	if (port->type == PORT_16C950) {
 		/* Wake up and initialize UART */
 		up->acr = 0;
 		serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
 		serial_port_out(port, UART_EFR, UART_EFR_ECB);
 		serial_port_out(port, UART_IER, 0);
 		serial_port_out(port, UART_LCR, 0);
 		serial_icr_write(up, UART_CSR, 0); /* Reset the UART */
 		serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
 		serial_port_out(port, UART_EFR, UART_EFR_ECB);
 		serial_port_out(port, UART_LCR, 0);
 	}
 #ifdef CONFIG_SERIAL_8250_RSA
 	/*
 	 * If this is an RSA port, see if we can kick it up to the
 	 * higher speed clock.
 	 */
 	enable_rsa(up);
 #endif
 	/*
 	 * Clear the FIFO buffers and disable them.
 	 * (they will be reenabled in set_termios())
 	 */
 	serial8250_clear_fifos(up);
 	/*
 	 * Clear the interrupt registers.
 	 */
-	if (serial_port_in(port, UART_LSR) & UART_LSR_DR)
+	serial_port_in(port, UART_LSR);
-		serial_port_in(port, UART_RX);
+	serial_port_in(port, UART_RX);
 	serial_port_in(port, UART_IIR);
 	serial_port_in(port, UART_MSR);
 	/*
 	 * At this point, there's no way the LSR could still be 0xff;
 	 * if it is, then bail out, because there's likely no UART
 	 * here.
 	 */
 	if (!(port->flags & UPF_BUGGY_UART) &&
 	    (serial_port_in(port, UART_LSR) == 0xff)) {
 		printk_ratelimited(KERN_INFO "ttyS%d: LSR safety check engaged!\n",
 				   serial_index(port));
 		retval = -ENODEV;
 		goto out;
 	}
 	/*
 	 * For a XR16C850, we need to set the trigger levels
 	 */
 	if (port->type == PORT_16850) {
 		unsigned char fctr;
 		serial_out(up, UART_LCR, UART_LCR_CONF_MODE_B);
 		fctr = serial_in(up, UART_FCTR) & ~(UART_FCTR_RX|UART_FCTR_TX);
 		serial_port_out(port, UART_FCTR,
 				fctr | UART_FCTR_TRGD | UART_FCTR_RX);
 		serial_port_out(port, UART_TRG, UART_TRG_96);
 		serial_port_out(port, UART_FCTR,
 				fctr | UART_FCTR_TRGD | UART_FCTR_TX);
 		serial_port_out(port, UART_TRG, UART_TRG_96);
 		serial_port_out(port, UART_LCR, 0);
 	}
 	if (port->irq) {
 		unsigned char iir1;
 		/*
 		 * Test for UARTs that do not reassert THRE when the
 		 * transmitter is idle and the interrupt has already
 		 * been cleared.  Real 16550s should always reassert
 		 * this interrupt whenever the transmitter is idle and
 		 * the interrupt is enabled.  Delays are necessary to
 		 * allow register changes to become visible.
 		 */
 		spin_lock_irqsave(&port->lock, flags);
 		if (up->port.irqflags & IRQF_SHARED)
 			disable_irq_nosync(port->irq);
 		wait_for_xmitr(up, UART_LSR_THRE);
 		serial_port_out_sync(port, UART_IER, UART_IER_THRI);
 		udelay(1); /* allow THRE to set */
 		iir1 = serial_port_in(port, UART_IIR);
 		serial_port_out(port, UART_IER, 0);
 		serial_port_out_sync(port, UART_IER, UART_IER_THRI);
 		udelay(1); /* allow a working UART time to re-assert THRE */
 		iir = serial_port_in(port, UART_IIR);
 		serial_port_out(port, UART_IER, 0);
 		if (port->irqflags & IRQF_SHARED)
 			enable_irq(port->irq);
 		spin_unlock_irqrestore(&port->lock, flags);
 		/*
 		 * If the interrupt is not reasserted, or we otherwise
 		 * don't trust the iir, setup a timer to kick the UART
 		 * on a regular basis.
 		 */
 		if ((!(iir1 & UART_IIR_NO_INT) && (iir & UART_IIR_NO_INT)) ||
 		    up->port.flags & UPF_BUG_THRE) {
 			up->bugs |= UART_BUG_THRE;
 			pr_debug("ttyS%d - using backup timer\n",
 				 serial_index(port));
 		}
 	}
 	/*
 	 * The above check will only give an accurate result the first time
 	 * the port is opened so this value needs to be preserved.
 	 */
 	if (up->bugs & UART_BUG_THRE) {
 		up->timer.function = serial8250_backup_timeout;
 		up->timer.data = (unsigned long)up;
 		mod_timer(&up->timer, jiffies +
 			uart_poll_timeout(port) + HZ / 5);
 	}
 	/*
 	 * If the "interrupt" for this port doesn't correspond with any
 	 * hardware interrupt, we use a timer-based system.  The original
 	 * driver used to do this with IRQ0.
 	 */
 	if (!port->irq) {
 		up->timer.data = (unsigned long)up;
 		mod_timer(&up->timer, jiffies + uart_poll_timeout(port));
 	} else {
 		retval = serial_link_irq_chain(up);
 		if (retval)
 			goto out;
 	}
 	/*
 	 * Now, initialize the UART
 	 */
 	serial_port_out(port, UART_LCR, UART_LCR_WLEN8);
 	spin_lock_irqsave(&port->lock, flags);
 	if (up->port.flags & UPF_FOURPORT) {
 		if (!up->port.irq)
 			up->port.mctrl |= TIOCM_OUT1;
 	} else
 		/*
 		 * Most PC uarts need OUT2 raised to enable interrupts.
 		 */
 		if (port->irq)
 			up->port.mctrl |= TIOCM_OUT2;
 	serial8250_set_mctrl(port, port->mctrl);
 	/* Serial over Lan (SoL) hack:
 	   Intel 8257x Gigabit ethernet chips have a
 	   16550 emulation, to be used for Serial Over Lan.
 	   Those chips take a longer time than a normal
 	   serial device to signalize that a transmission
 	   data was queued. Due to that, the above test generally
 	   fails. One solution would be to delay the reading of
 	   iir. However, this is not reliable, since the timeout
 	   is variable. So, let's just don't test if we receive
 	   TX irq. This way, we'll never enable UART_BUG_TXEN.
 	 */
 	if (skip_txen_test || up->port.flags & UPF_NO_TXEN_TEST)
 		goto dont_test_tx_en;
 	/*
 	 * Do a quick test to see if we receive an
 	 * interrupt when we enable the TX irq.
 	 */
 	serial_port_out(port, UART_IER, UART_IER_THRI);
 	lsr = serial_port_in(port, UART_LSR);
 	iir = serial_port_in(port, UART_IIR);
 	serial_port_out(port, UART_IER, 0);
 	if (lsr & UART_LSR_TEMT && iir & UART_IIR_NO_INT) {
 		if (!(up->bugs & UART_BUG_TXEN)) {
 			up->bugs |= UART_BUG_TXEN;
 			pr_debug("ttyS%d - enabling bad tx status workarounds\n",
 				 serial_index(port));
 		}
 	} else {
 		up->bugs &= ~UART_BUG_TXEN;
 	}
 dont_test_tx_en:
 	spin_unlock_irqrestore(&port->lock, flags);
 	/*
 	 * Clear the interrupt registers again for luck, and clear the
 	 * saved flags to avoid getting false values from polling
 	 * routines or the previous session.
 	 */
-	if (serial_port_in(port, UART_LSR) & UART_LSR_DR)
+	serial_port_in(port, UART_LSR);
-		serial_port_in(port, UART_RX);
+	serial_port_in(port, UART_RX);
 	serial_port_in(port, UART_IIR);
 	serial_port_in(port, UART_MSR);
 	up->lsr_saved_flags = 0;
 	up->msr_saved_flags = 0;
 	/*
 	 * Request DMA channels for both RX and TX.
 	 */
 	if (up->dma) {
 		retval = serial8250_request_dma(up);
 		if (retval) {
 			pr_warn_ratelimited("ttyS%d - failed to request DMA\n",
 					    serial_index(port));
 			up->dma = NULL;
 		}
 	}
 	/*
 	 * Finally, enable interrupts.  Note: Modem status interrupts
 	 * are set via set_termios(), which will be occurring imminently
 	 * anyway, so we don't enable them here.
 	 */
 	up->ier = UART_IER_RLSI | UART_IER_RDI;
 	serial_port_out(port, UART_IER, up->ier);
 	if (port->flags & UPF_FOURPORT) {
 		unsigned int icp;
 		/*
 		 * Enable interrupts on the AST Fourport board
 		 */
 		icp = (port->iobase & 0xfe0) | 0x01f;
 		outb_p(0x80, icp);
 		inb_p(icp);
 	}
 	retval = 0;
 out:
 	serial8250_rpm_put(up);
 	return retval;
 }
 EXPORT_SYMBOL_GPL(serial8250_do_startup);
 static int serial8250_startup(struct uart_port *port)
 {
 	if (port->startup)
 		return port->startup(port);
 	return serial8250_do_startup(port);
 }
 void serial8250_do_shutdown(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	unsigned long flags;
 	serial8250_rpm_get(up);
 	/*
 	 * Disable interrupts from this port
 	 */
 	up->ier = 0;
 	serial_port_out(port, UART_IER, 0);
 	if (up->dma)
 		serial8250_release_dma(up);
 	spin_lock_irqsave(&port->lock, flags);
 	if (port->flags & UPF_FOURPORT) {
 		/* reset interrupts on the AST Fourport board */
 		inb((port->iobase & 0xfe0) | 0x1f);
 		port->mctrl |= TIOCM_OUT1;
 	} else
 		port->mctrl &= ~TIOCM_OUT2;
 	serial8250_set_mctrl(port, port->mctrl);
 	spin_unlock_irqrestore(&port->lock, flags);
 	/*
 	 * Disable break condition and FIFOs
 	 */
 	serial_port_out(port, UART_LCR,
 			serial_port_in(port, UART_LCR) & ~UART_LCR_SBC);
 	serial8250_clear_fifos(up);
 #ifdef CONFIG_SERIAL_8250_RSA
 	/*
 	 * Reset the RSA board back to 115kbps compat mode.
 	 */
 	disable_rsa(up);
 #endif
 	/*
 	 * Read data port to reset things, and then unlink from
 	 * the IRQ chain.
 	 */
-	if (serial_port_in(port, UART_LSR) & UART_LSR_DR)
+	serial_port_in(port, UART_RX);
-		serial_port_in(port, UART_RX);
 	serial8250_rpm_put(up);
 	del_timer_sync(&up->timer);
 	up->timer.function = serial8250_timeout;
 	if (port->irq)
 		serial_unlink_irq_chain(up);
 }
 EXPORT_SYMBOL_GPL(serial8250_do_shutdown);
 static void serial8250_shutdown(struct uart_port *port)
 {
 	if (port->shutdown)
 		port->shutdown(port);
 	else
 		serial8250_do_shutdown(port);
 }
 /*
  * XR17V35x UARTs have an extra fractional divisor register (DLD)
  * Calculate divisor with extra 4-bit fractional portion
  */
 static unsigned int xr17v35x_get_divisor(struct uart_8250_port *up,
 					 unsigned int baud,
 					 unsigned int *frac)
 {
 	struct uart_port *port = &up->port;
 	unsigned int quot_16;
 	quot_16 = DIV_ROUND_CLOSEST(port->uartclk, baud);
 	*frac = quot_16 & 0x0f;
 	return quot_16 >> 4;
 }
 static unsigned int serial8250_get_divisor(struct uart_8250_port *up,
 					   unsigned int baud,
 					   unsigned int *frac)
 {
 	struct uart_port *port = &up->port;
 	unsigned int quot;
 	/*
 	 * Handle magic divisors for baud rates above baud_base on
 	 * SMSC SuperIO chips.
 	 *
 	 */
 	if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
 	    baud == (port->uartclk/4))
 		quot = 0x8001;
 	else if ((port->flags & UPF_MAGIC_MULTIPLIER) &&
 		 baud == (port->uartclk/8))
 		quot = 0x8002;
 	else if (up->port.type == PORT_XR17V35X)
 		quot = xr17v35x_get_divisor(up, baud, frac);
 	else
 		quot = uart_get_divisor(port, baud);
 	/*
 	 * Oxford Semi 952 rev B workaround
 	 */
 	if (up->bugs & UART_BUG_QUOT && (quot & 0xff) == 0)
 		quot++;
 	return quot;
 }
 static unsigned char serial8250_compute_lcr(struct uart_8250_port *up,
 					    tcflag_t c_cflag)
 {
 	unsigned char cval;
 	switch (c_cflag & CSIZE) {
 	case CS5:
 		cval = UART_LCR_WLEN5;
 		break;
 	case CS6:
 		cval = UART_LCR_WLEN6;
 		break;
 	case CS7:
 		cval = UART_LCR_WLEN7;
 		break;
 	default:
 	case CS8:
 		cval = UART_LCR_WLEN8;
 		break;
 	}
 	if (c_cflag & CSTOPB)
 		cval |= UART_LCR_STOP;
 	if (c_cflag & PARENB) {
 		cval |= UART_LCR_PARITY;
 		if (up->bugs & UART_BUG_PARITY)
 			up->fifo_bug = true;
 	}
 	if (!(c_cflag & PARODD))
 		cval |= UART_LCR_EPAR;
 #ifdef CMSPAR
 	if (c_cflag & CMSPAR)
 		cval |= UART_LCR_SPAR;
 #endif
 	return cval;
 }
 static void serial8250_set_divisor(struct uart_port *port, unsigned int baud,
 			    unsigned int quot, unsigned int quot_frac)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	/* Workaround to enable 115200 baud on OMAP1510 internal ports */
 	if (is_omap1510_8250(up)) {
 		if (baud == 115200) {
 			quot = 1;
 			serial_port_out(port, UART_OMAP_OSC_12M_SEL, 1);
 		} else
 			serial_port_out(port, UART_OMAP_OSC_12M_SEL, 0);
 	}
 	/*
 	 * For NatSemi, switch to bank 2 not bank 1, to avoid resetting EXCR2,
 	 * otherwise just set DLAB
 	 */
 	if (up->capabilities & UART_NATSEMI)
 		serial_port_out(port, UART_LCR, 0xe0);
 	else
 		serial_port_out(port, UART_LCR, up->lcr | UART_LCR_DLAB);
 	serial_dl_write(up, quot);
 	/* XR17V35x UARTs have an extra fractional divisor register (DLD) */
 	if (up->port.type == PORT_XR17V35X)
 		serial_port_out(port, 0x2, quot_frac);
 }
 void
 serial8250_do_set_termios(struct uart_port *port, struct ktermios *termios,
 		          struct ktermios *old)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	unsigned char cval;
 	unsigned long flags;
 	unsigned int baud, quot, frac = 0;
 	cval = serial8250_compute_lcr(up, termios->c_cflag);
 	/*
 	 * Ask the core to calculate the divisor for us.
 	 */
 	baud = uart_get_baud_rate(port, termios, old,
 				  port->uartclk / 16 / 0xffff,
 				  port->uartclk / 16);
 	quot = serial8250_get_divisor(up, baud, &frac);
 	/*
 	 * Ok, we're now changing the port state.  Do it with
 	 * interrupts disabled.
 	 */
 	serial8250_rpm_get(up);
 	spin_lock_irqsave(&port->lock, flags);
 	up->lcr = cval;					/* Save computed LCR */
 	if (up->capabilities & UART_CAP_FIFO && port->fifosize > 1) {
 		/* NOTE: If fifo_bug is not set, a user can set RX_trigger. */
 		if ((baud < 2400 && !up->dma) || up->fifo_bug) {
 			up->fcr &= ~UART_FCR_TRIGGER_MASK;
 			up->fcr |= UART_FCR_TRIGGER_1;
 		}
 	}
 	/*
 	 * MCR-based auto flow control.  When AFE is enabled, RTS will be
 	 * deasserted when the receive FIFO contains more characters than
 	 * the trigger, or the MCR RTS bit is cleared.  In the case where
 	 * the remote UART is not using CTS auto flow control, we must
 	 * have sufficient FIFO entries for the latency of the remote
 	 * UART to respond.  IOW, at least 32 bytes of FIFO.
 	 */
 	if (up->capabilities & UART_CAP_AFE && port->fifosize >= 32) {
 		up->mcr &= ~UART_MCR_AFE;
 		if (termios->c_cflag & CRTSCTS)
 			up->mcr |= UART_MCR_AFE;
 	}
 	/*
 	 * Update the per-port timeout.
 	 */
 	uart_update_timeout(port, termios->c_cflag, baud);
 	port->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR;
 	if (termios->c_iflag & INPCK)
 		port->read_status_mask |= UART_LSR_FE | UART_LSR_PE;
 	if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
 		port->read_status_mask |= UART_LSR_BI;
 	/*
 	 * Characteres to ignore
 	 */
 	port->ignore_status_mask = 0;
 	if (termios->c_iflag & IGNPAR)
 		port->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE;
 	if (termios->c_iflag & IGNBRK) {
 		port->ignore_status_mask |= UART_LSR_BI;
 		/*
 		 * If we're ignoring parity and break indicators,
 		 * ignore overruns too (for real raw support).
 		 */
 		if (termios->c_iflag & IGNPAR)
 			port->ignore_status_mask |= UART_LSR_OE;
 	}
 	/*
 	 * ignore all characters if CREAD is not set
 	 */
 	if ((termios->c_cflag & CREAD) == 0)
 		port->ignore_status_mask |= UART_LSR_DR;
 	/*
 	 * CTS flow control flag and modem status interrupts
 	 */
 	up->ier &= ~UART_IER_MSI;
 	if (!(up->bugs & UART_BUG_NOMSR) &&
 			UART_ENABLE_MS(&up->port, termios->c_cflag))
 		up->ier |= UART_IER_MSI;
 	if (up->capabilities & UART_CAP_UUE)
 		up->ier |= UART_IER_UUE;
 	if (up->capabilities & UART_CAP_RTOIE)
 		up->ier |= UART_IER_RTOIE;
 	serial_port_out(port, UART_IER, up->ier);
 	if (up->capabilities & UART_CAP_EFR) {
 		unsigned char efr = 0;
 		/*
 		 * TI16C752/Startech hardware flow control.  FIXME:
 		 * - TI16C752 requires control thresholds to be set.
 		 * - UART_MCR_RTS is ineffective if auto-RTS mode is enabled.
 		 */
 		if (termios->c_cflag & CRTSCTS)
 			efr |= UART_EFR_CTS;
 		serial_port_out(port, UART_LCR, UART_LCR_CONF_MODE_B);
 		if (port->flags & UPF_EXAR_EFR)
 			serial_port_out(port, UART_XR_EFR, efr);
 		else
 			serial_port_out(port, UART_EFR, efr);
 	}
 	serial8250_set_divisor(port, baud, quot, frac);
 	/*
 	 * LCR DLAB must be set to enable 64-byte FIFO mode. If the FCR
 	 * is written without DLAB set, this mode will be disabled.
 	 */
 	if (port->type == PORT_16750)
 		serial_port_out(port, UART_FCR, up->fcr);
 	serial_port_out(port, UART_LCR, up->lcr);	/* reset DLAB */
 	if (port->type != PORT_16750) {
 		/* emulated UARTs (Lucent Venus 167x) need two steps */
 		if (up->fcr & UART_FCR_ENABLE_FIFO)
 			serial_port_out(port, UART_FCR, UART_FCR_ENABLE_FIFO);
 		serial_port_out(port, UART_FCR, up->fcr);	/* set fcr */
 	}
 	serial8250_set_mctrl(port, port->mctrl);
 	spin_unlock_irqrestore(&port->lock, flags);
 	serial8250_rpm_put(up);
 	/* Don't rewrite B0 */
 	if (tty_termios_baud_rate(termios))
 		tty_termios_encode_baud_rate(termios, baud, baud);
 }
 EXPORT_SYMBOL(serial8250_do_set_termios);
 static void
 serial8250_set_termios(struct uart_port *port, struct ktermios *termios,
 		       struct ktermios *old)
 {
 	if (port->set_termios)
 		port->set_termios(port, termios, old);
 	else
 		serial8250_do_set_termios(port, termios, old);
 }
 static void
 serial8250_set_ldisc(struct uart_port *port, struct ktermios *termios)
 {
 	if (termios->c_line == N_PPS) {
 		port->flags |= UPF_HARDPPS_CD;
 		spin_lock_irq(&port->lock);
 		serial8250_enable_ms(port);
 		spin_unlock_irq(&port->lock);
 	} else {
 		port->flags &= ~UPF_HARDPPS_CD;
 		if (!UART_ENABLE_MS(port, termios->c_cflag)) {
 			spin_lock_irq(&port->lock);
 			serial8250_disable_ms(port);
 			spin_unlock_irq(&port->lock);
 		}
 	}
 }
 void serial8250_do_pm(struct uart_port *port, unsigned int state,
 		      unsigned int oldstate)
 {
 	struct uart_8250_port *p = up_to_u8250p(port);
 	serial8250_set_sleep(p, state != 0);
 }
 EXPORT_SYMBOL(serial8250_do_pm);
 static void
 serial8250_pm(struct uart_port *port, unsigned int state,
 	      unsigned int oldstate)
 {
 	if (port->pm)
 		port->pm(port, state, oldstate);
 	else
 		serial8250_do_pm(port, state, oldstate);
 }
 static unsigned int serial8250_port_size(struct uart_8250_port *pt)
 {
 	if (pt->port.iotype == UPIO_AU) {
 		if (pt->port.type == PORT_RT2880)
 			return 0x100;
 		return 0x1000;
 	}
 	if (is_omap1_8250(pt))
 		return 0x16 << pt->port.regshift;
 	return 8 << pt->port.regshift;
 }
 /*
  * Resource handling.
  */
 static int serial8250_request_std_resource(struct uart_8250_port *up)
 {
 	unsigned int size = serial8250_port_size(up);
 	struct uart_port *port = &up->port;
 	int ret = 0;
 	switch (port->iotype) {
 	case UPIO_AU:
 	case UPIO_TSI:
 	case UPIO_MEM32:
 	case UPIO_MEM:
 		if (!port->mapbase)
 			break;
 		if (!request_mem_region(port->mapbase, size, "serial")) {
 			ret = -EBUSY;
 			break;
 		}
 		if (port->flags & UPF_IOREMAP) {
 			port->membase = ioremap_nocache(port->mapbase, size);
 			if (!port->membase) {
 				release_mem_region(port->mapbase, size);
 				ret = -ENOMEM;
 			}
 		}
 		break;
 	case UPIO_HUB6:
 	case UPIO_PORT:
 		if (!request_region(port->iobase, size, "serial"))
 			ret = -EBUSY;
 		break;
 	}
 	return ret;
 }
 static void serial8250_release_std_resource(struct uart_8250_port *up)
 {
 	unsigned int size = serial8250_port_size(up);
 	struct uart_port *port = &up->port;
 	switch (port->iotype) {
 	case UPIO_AU:
 	case UPIO_TSI:
 	case UPIO_MEM32:
 	case UPIO_MEM:
 		if (!port->mapbase)
 			break;
 		if (port->flags & UPF_IOREMAP) {
 			iounmap(port->membase);
 			port->membase = NULL;
 		}
 		release_mem_region(port->mapbase, size);
 		break;
 	case UPIO_HUB6:
 	case UPIO_PORT:
 		release_region(port->iobase, size);
 		break;
 	}
 }
 static int serial8250_request_rsa_resource(struct uart_8250_port *up)
 {
 	unsigned long start = UART_RSA_BASE << up->port.regshift;
 	unsigned int size = 8 << up->port.regshift;
 	struct uart_port *port = &up->port;
 	int ret = -EINVAL;
 	switch (port->iotype) {
 	case UPIO_HUB6:
 	case UPIO_PORT:
 		start += port->iobase;
 		if (request_region(start, size, "serial-rsa"))
 			ret = 0;
 		else
 			ret = -EBUSY;
 		break;
 	}
 	return ret;
 }
 static void serial8250_release_rsa_resource(struct uart_8250_port *up)
 {
 	unsigned long offset = UART_RSA_BASE << up->port.regshift;
 	unsigned int size = 8 << up->port.regshift;
 	struct uart_port *port = &up->port;
 	switch (port->iotype) {
 	case UPIO_HUB6:
 	case UPIO_PORT:
 		release_region(port->iobase + offset, size);
 		break;
 	}
 }
 static void serial8250_release_port(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	serial8250_release_std_resource(up);
 	if (port->type == PORT_RSA)
 		serial8250_release_rsa_resource(up);
 }
 static int serial8250_request_port(struct uart_port *port)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	int ret;
 	if (port->type == PORT_8250_CIR)
 		return -ENODEV;
 	ret = serial8250_request_std_resource(up);
 	if (ret == 0 && port->type == PORT_RSA) {
 		ret = serial8250_request_rsa_resource(up);
 		if (ret < 0)
 			serial8250_release_std_resource(up);
 	}
 	return ret;
 }
 static int fcr_get_rxtrig_bytes(struct uart_8250_port *up)
 {
 	const struct serial8250_config *conf_type = &uart_config[up->port.type];
 	unsigned char bytes;
 	bytes = conf_type->rxtrig_bytes[UART_FCR_R_TRIG_BITS(up->fcr)];
 	return bytes ? bytes : -EOPNOTSUPP;
 }
 static int bytes_to_fcr_rxtrig(struct uart_8250_port *up, unsigned char bytes)
 {
 	const struct serial8250_config *conf_type = &uart_config[up->port.type];
 	int i;
 	if (!conf_type->rxtrig_bytes[UART_FCR_R_TRIG_BITS(UART_FCR_R_TRIG_00)])
 		return -EOPNOTSUPP;
 	for (i = 1; i < UART_FCR_R_TRIG_MAX_STATE; i++) {
 		if (bytes < conf_type->rxtrig_bytes[i])
 			/* Use the nearest lower value */
 			return (--i) << UART_FCR_R_TRIG_SHIFT;
 	}
 	return UART_FCR_R_TRIG_11;
 }
 static int do_get_rxtrig(struct tty_port *port)
 {
 	struct uart_state *state = container_of(port, struct uart_state, port);
 	struct uart_port *uport = state->uart_port;
 	struct uart_8250_port *up =
 		container_of(uport, struct uart_8250_port, port);
 	if (!(up->capabilities & UART_CAP_FIFO) || uport->fifosize <= 1)
 		return -EINVAL;
 	return fcr_get_rxtrig_bytes(up);
 }
 static int do_serial8250_get_rxtrig(struct tty_port *port)
 {
 	int rxtrig_bytes;
 	mutex_lock(&port->mutex);
 	rxtrig_bytes = do_get_rxtrig(port);
 	mutex_unlock(&port->mutex);
 	return rxtrig_bytes;
 }
 static ssize_t serial8250_get_attr_rx_trig_bytes(struct device *dev,
 	struct device_attribute *attr, char *buf)
 {
 	struct tty_port *port = dev_get_drvdata(dev);
 	int rxtrig_bytes;
 	rxtrig_bytes = do_serial8250_get_rxtrig(port);
 	if (rxtrig_bytes < 0)
 		return rxtrig_bytes;
 	return snprintf(buf, PAGE_SIZE, "%d\n", rxtrig_bytes);
 }
 static int do_set_rxtrig(struct tty_port *port, unsigned char bytes)
 {
 	struct uart_state *state = container_of(port, struct uart_state, port);
 	struct uart_port *uport = state->uart_port;
 	struct uart_8250_port *up =
 		container_of(uport, struct uart_8250_port, port);
 	int rxtrig;
 	if (!(up->capabilities & UART_CAP_FIFO) || uport->fifosize <= 1 ||
 	    up->fifo_bug)
 		return -EINVAL;
 	rxtrig = bytes_to_fcr_rxtrig(up, bytes);
 	if (rxtrig < 0)
 		return rxtrig;
 	serial8250_clear_fifos(up);
 	up->fcr &= ~UART_FCR_TRIGGER_MASK;
 	up->fcr |= (unsigned char)rxtrig;
 	serial_out(up, UART_FCR, up->fcr);
 	return 0;
 }
 static int do_serial8250_set_rxtrig(struct tty_port *port, unsigned char bytes)
 {
 	int ret;
 	mutex_lock(&port->mutex);
 	ret = do_set_rxtrig(port, bytes);
 	mutex_unlock(&port->mutex);
 	return ret;
 }
 static ssize_t serial8250_set_attr_rx_trig_bytes(struct device *dev,
 	struct device_attribute *attr, const char *buf, size_t count)
 {
 	struct tty_port *port = dev_get_drvdata(dev);
 	unsigned char bytes;
 	int ret;
 	if (!count)
 		return -EINVAL;
 	ret = kstrtou8(buf, 10, &bytes);
 	if (ret < 0)
 		return ret;
 	ret = do_serial8250_set_rxtrig(port, bytes);
 	if (ret < 0)
 		return ret;
 	return count;
 }
 static DEVICE_ATTR(rx_trig_bytes, S_IRUSR | S_IWUSR | S_IRGRP,
 		   serial8250_get_attr_rx_trig_bytes,
 		   serial8250_set_attr_rx_trig_bytes);
 static struct attribute *serial8250_dev_attrs[] = {
 	&dev_attr_rx_trig_bytes.attr,
 	NULL,
 	};
 static struct attribute_group serial8250_dev_attr_group = {
 	.attrs = serial8250_dev_attrs,
 	};
 static void register_dev_spec_attr_grp(struct uart_8250_port *up)
 {
 	const struct serial8250_config *conf_type = &uart_config[up->port.type];
 	if (conf_type->rxtrig_bytes[0])
 		up->port.attr_group = &serial8250_dev_attr_group;
 }
 static void serial8250_config_port(struct uart_port *port, int flags)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	int probeflags = PROBE_ANY;
 	int ret;
 	if (port->type == PORT_8250_CIR)
 		return;
 	/*
 	 * Find the region that we can probe for.  This in turn
 	 * tells us whether we can probe for the type of port.
 	 */
 	ret = serial8250_request_std_resource(up);
 	if (ret < 0)
 		return;
 	ret = serial8250_request_rsa_resource(up);
 	if (ret < 0)
 		probeflags &= ~PROBE_RSA;
 	if (port->iotype != up->cur_iotype)
 		set_io_from_upio(port);
 	if (flags & UART_CONFIG_TYPE)
 		autoconfig(up, probeflags);
 	/* if access method is AU, it is a 16550 with a quirk */
 	if (port->type == PORT_16550A && port->iotype == UPIO_AU)
 		up->bugs |= UART_BUG_NOMSR;
 	/* HW bugs may trigger IRQ while IIR == NO_INT */
 	if (port->type == PORT_TEGRA)
 		up->bugs |= UART_BUG_NOMSR;
 	if (port->type != PORT_UNKNOWN && flags & UART_CONFIG_IRQ)
 		autoconfig_irq(up);
 	if (port->type != PORT_RSA && probeflags & PROBE_RSA)
 		serial8250_release_rsa_resource(up);
 	if (port->type == PORT_UNKNOWN)
 		serial8250_release_std_resource(up);
 	/* Fixme: probably not the best place for this */
 	if ((port->type == PORT_XR17V35X) ||
 	   (port->type == PORT_XR17D15X))
 		port->handle_irq = exar_handle_irq;
 	register_dev_spec_attr_grp(up);
 	up->fcr = uart_config[up->port.type].fcr;
 }
 static int
 serial8250_verify_port(struct uart_port *port, struct serial_struct *ser)
 {
 	if (ser->irq >= nr_irqs || ser->irq < 0 ||
 	    ser->baud_base < 9600 || ser->type < PORT_UNKNOWN ||
 	    ser->type >= ARRAY_SIZE(uart_config) || ser->type == PORT_CIRRUS ||
 	    ser->type == PORT_STARTECH)
 		return -EINVAL;
 	return 0;
 }
 static const char *
 serial8250_type(struct uart_port *port)
 {
 	int type = port->type;
 	if (type >= ARRAY_SIZE(uart_config))
 		type = 0;
 	return uart_config[type].name;
 }
 static struct uart_ops serial8250_pops = {
 	.tx_empty	= serial8250_tx_empty,
 	.set_mctrl	= serial8250_set_mctrl,
 	.get_mctrl	= serial8250_get_mctrl,
 	.stop_tx	= serial8250_stop_tx,
 	.start_tx	= serial8250_start_tx,
 	.throttle	= serial8250_throttle,
 	.unthrottle	= serial8250_unthrottle,
 	.stop_rx	= serial8250_stop_rx,
 	.enable_ms	= serial8250_enable_ms,
 	.break_ctl	= serial8250_break_ctl,
 	.startup	= serial8250_startup,
 	.shutdown	= serial8250_shutdown,
 	.set_termios	= serial8250_set_termios,
 	.set_ldisc	= serial8250_set_ldisc,
 	.pm		= serial8250_pm,
 	.type		= serial8250_type,
 	.release_port	= serial8250_release_port,
 	.request_port	= serial8250_request_port,
 	.config_port	= serial8250_config_port,
 	.verify_port	= serial8250_verify_port,
 #ifdef CONFIG_CONSOLE_POLL
 	.poll_get_char = serial8250_get_poll_char,
 	.poll_put_char = serial8250_put_poll_char,
 #endif
 };
 static struct uart_8250_port serial8250_ports[UART_NR];
 /**
  * serial8250_get_port - retrieve struct uart_8250_port
  * @line: serial line number
  *
  * This function retrieves struct uart_8250_port for the specific line.
  * This struct *must* *not* be used to perform a 8250 or serial core operation
  * which is not accessible otherwise. Its only purpose is to make the struct
  * accessible to the runtime-pm callbacks for context suspend/restore.
  * The lock assumption made here is none because runtime-pm suspend/resume
  * callbacks should not be invoked if there is any operation performed on the
  * port.
  */
 struct uart_8250_port *serial8250_get_port(int line)
 {
 	return &serial8250_ports[line];
 }
 EXPORT_SYMBOL_GPL(serial8250_get_port);
 static void (*serial8250_isa_config)(int port, struct uart_port *up,
 	unsigned short *capabilities);
 void serial8250_set_isa_configurator(
 	void (*v)(int port, struct uart_port *up, unsigned short *capabilities))
 {
 	serial8250_isa_config = v;
 }
 EXPORT_SYMBOL(serial8250_set_isa_configurator);
 static void __init serial8250_isa_init_ports(void)
 {
 	struct uart_8250_port *up;
 	static int first = 1;
 	int i, irqflag = 0;
 	if (!first)
 		return;
 	first = 0;
 	if (nr_uarts > UART_NR)
 		nr_uarts = UART_NR;
 	for (i = 0; i < nr_uarts; i++) {
 		struct uart_8250_port *up = &serial8250_ports[i];
 		struct uart_port *port = &up->port;
 		port->line = i;
 		spin_lock_init(&port->lock);
 		init_timer(&up->timer);
 		up->timer.function = serial8250_timeout;
 		up->cur_iotype = 0xFF;
 		/*
 		 * ALPHA_KLUDGE_MCR needs to be killed.
 		 */
 		up->mcr_mask = ~ALPHA_KLUDGE_MCR;
 		up->mcr_force = ALPHA_KLUDGE_MCR;
 		port->ops = &serial8250_pops;
 	}
 	if (share_irqs)
 		irqflag = IRQF_SHARED;
 	for (i = 0, up = serial8250_ports;
 	     i < ARRAY_SIZE(old_serial_port) && i < nr_uarts;
 	     i++, up++) {
 		struct uart_port *port = &up->port;
 		port->iobase   = old_serial_port[i].port;
 		port->irq      = irq_canonicalize(old_serial_port[i].irq);
 		port->irqflags = old_serial_port[i].irqflags;
 		port->uartclk  = old_serial_port[i].baud_base * 16;
 		port->flags    = old_serial_port[i].flags;
 		port->hub6     = old_serial_port[i].hub6;
 		port->membase  = old_serial_port[i].iomem_base;
 		port->iotype   = old_serial_port[i].io_type;
 		port->regshift = old_serial_port[i].iomem_reg_shift;
 		set_io_from_upio(port);
 		port->irqflags |= irqflag;
 		if (serial8250_isa_config != NULL)
 			serial8250_isa_config(i, &up->port, &up->capabilities);
 	}
 }
 static void
 serial8250_init_fixed_type_port(struct uart_8250_port *up, unsigned int type)
 {
 	up->port.type = type;
 	if (!up->port.fifosize)
 		up->port.fifosize = uart_config[type].fifo_size;
 	if (!up->tx_loadsz)
 		up->tx_loadsz = uart_config[type].tx_loadsz;
 	if (!up->capabilities)
 		up->capabilities = uart_config[type].flags;
 }
 static void __init
 serial8250_register_ports(struct uart_driver *drv, struct device *dev)
 {
 	int i;
 	for (i = 0; i < nr_uarts; i++) {
 		struct uart_8250_port *up = &serial8250_ports[i];
 		if (up->port.dev)
 			continue;
 		up->port.dev = dev;
 		if (up->port.flags & UPF_FIXED_TYPE)
 			serial8250_init_fixed_type_port(up, up->port.type);
 		uart_add_one_port(drv, &up->port);
 	}
 }
 #ifdef CONFIG_SERIAL_8250_CONSOLE
 static void serial8250_console_putchar(struct uart_port *port, int ch)
 {
 	struct uart_8250_port *up = up_to_u8250p(port);
 	wait_for_xmitr(up, UART_LSR_THRE);
 	serial_port_out(port, UART_TX, ch);
 }
 /*
  *	Print a string to the serial port trying not to disturb
  *	any possible real use of the port...
  *
  *	The console_lock must be held when we get here.
  */
 static void
 serial8250_console_write(struct console *co, const char *s, unsigned int count)
 {
 	struct uart_8250_port *up = &serial8250_ports[co->index];
 	struct uart_port *port = &up->port;
 	unsigned long flags;
 	unsigned int ier;
 	int locked = 1;
 	touch_nmi_watchdog();
 	serial8250_rpm_get(up);
 	if (port->sysrq)
 		locked = 0;
 	else if (oops_in_progress)
 		locked = spin_trylock_irqsave(&port->lock, flags);
 	else
 		spin_lock_irqsave(&port->lock, flags);
 	/*
 	 *	First save the IER then disable the interrupts
 	 */
 	ier = serial_port_in(port, UART_IER);
 	if (up->capabilities & UART_CAP_UUE)
 		serial_port_out(port, UART_IER, UART_IER_UUE);
 	else
 		serial_port_out(port, UART_IER, 0);
 	/* check scratch reg to see if port powered off during system sleep */
 	if (up->canary && (up->canary != serial_port_in(port, UART_SCR))) {
 		struct ktermios termios;
 		unsigned int baud, quot, frac = 0;
 		termios.c_cflag = port->cons->cflag;
 		if (port->state->port.tty && termios.c_cflag == 0)
 			termios.c_cflag = port->state->port.tty->termios.c_cflag;
 		baud = uart_get_baud_rate(port, &termios, NULL,
 					  port->uartclk / 16 / 0xffff,
 					  port->uartclk / 16);
 		quot = serial8250_get_divisor(up, baud, &frac);
 		serial8250_set_divisor(port, baud, quot, frac);
 		serial_port_out(port, UART_LCR, up->lcr);
 		serial_port_out(port, UART_MCR, UART_MCR_DTR | UART_MCR_RTS);
 		up->canary = 0;
 	}
 	uart_console_write(port, s, count, serial8250_console_putchar);
 	/*
 	 *	Finally, wait for transmitter to become empty
 	 *	and restore the IER
 	 */
 	wait_for_xmitr(up, BOTH_EMPTY);
 	serial_port_out(port, UART_IER, ier);
 	/*
 	 *	The receive handling will happen properly because the
 	 *	receive ready bit will still be set; it is not cleared
 	 *	on read.  However, modem control will not, we must
 	 *	call it if we have saved something in the saved flags
 	 *	while processing with interrupts off.
 	 */
 	if (up->msr_saved_flags)
 		serial8250_modem_status(up);
 	if (locked)
 		spin_unlock_irqrestore(&port->lock, flags);
 	serial8250_rpm_put(up);
 }
 static int serial8250_console_setup(struct console *co, char *options)
 {
 	struct uart_port *port;
 	int baud = 9600;
 	int bits = 8;
 	int parity = 'n';
 	int flow = 'n';
 	/*
 	 * Check whether an invalid uart number has been specified, and
 	 * if so, search for the first available port that does have
 	 * console support.
 	 */
 	if (co->index >= nr_uarts)
 		co->index = 0;
 	port = &serial8250_ports[co->index].port;
 	if (!port->iobase && !port->membase)
 		return -ENODEV;
 	if (options)
 		uart_parse_options(options, &baud, &parity, &bits, &flow);
 	return uart_set_options(port, co, baud, parity, bits, flow);
 }
 static int serial8250_console_early_setup(void)
 {
 	return serial8250_find_port_for_earlycon();
 }
 static struct console serial8250_console = {
 	.name		= "ttyS",
 	.write		= serial8250_console_write,
 	.device		= uart_console_device,
 	.setup		= serial8250_console_setup,
 	.early_setup	= serial8250_console_early_setup,
 	.flags		= CON_PRINTBUFFER | CON_ANYTIME,
 	.index		= -1,
 	.data		= &serial8250_reg,
 };
 static int __init serial8250_console_init(void)
 {
 	serial8250_isa_init_ports();
 	register_console(&serial8250_console);
 	return 0;
 }
 console_initcall(serial8250_console_init);
 int serial8250_find_port(struct uart_port *p)
 {
 	int line;
 	struct uart_port *port;
 	for (line = 0; line < nr_uarts; line++) {
 		port = &serial8250_ports[line].port;
 		if (uart_match_port(p, port))
 			return line;
 	}
 	return -ENODEV;
 }
 #define SERIAL8250_CONSOLE	&serial8250_console
 #else
 #define SERIAL8250_CONSOLE	NULL
 #endif
 static struct uart_driver serial8250_reg = {
 	.owner			= THIS_MODULE,
 	.driver_name		= "serial",
 	.dev_name		= "ttyS",
 	.major			= TTY_MAJOR,
 	.minor			= 64,
 	.cons			= SERIAL8250_CONSOLE,
 };
 /*
  * early_serial_setup - early registration for 8250 ports
  *
  * Setup an 8250 port structure prior to console initialisation.  Use
  * after console initialisation will cause undefined behaviour.
  */
 int __init early_serial_setup(struct uart_port *port)
 {
 	struct uart_port *p;
 	if (port->line >= ARRAY_SIZE(serial8250_ports))
 		return -ENODEV;
 	serial8250_isa_init_ports();
 	p = &serial8250_ports[port->line].port;
 	p->iobase       = port->iobase;
 	p->membase      = port->membase;
 	p->irq          = port->irq;
 	p->irqflags     = port->irqflags;
 	p->uartclk      = port->uartclk;
 	p->fifosize     = port->fifosize;
 	p->regshift     = port->regshift;
 	p->iotype       = port->iotype;
 	p->flags        = port->flags;
 	p->mapbase      = port->mapbase;
 	p->private_data = port->private_data;
 	p->type		= port->type;
 	p->line		= port->line;
 	set_io_from_upio(p);
 	if (port->serial_in)
 		p->serial_in = port->serial_in;
 	if (port->serial_out)
 		p->serial_out = port->serial_out;
 	if (port->handle_irq)
 		p->handle_irq = port->handle_irq;
 	else
 		p->handle_irq = serial8250_default_handle_irq;
 	return 0;
 }
 /**
  *	serial8250_suspend_port - suspend one serial port
  *	@line:  serial line number
  *
  *	Suspend one serial port.
  */
 void serial8250_suspend_port(int line)
 {
 	struct uart_8250_port *up = &serial8250_ports[line];
 	struct uart_port *port = &up->port;
 	if (!console_suspend_enabled && uart_console(port) &&
 	    port->type != PORT_8250) {
 		unsigned char canary = 0xa5;
 		serial_out(up, UART_SCR, canary);
 		up->canary = canary;
 	}
 	uart_suspend_port(&serial8250_reg, port);
 }
 /**
  *	serial8250_resume_port - resume one serial port
  *	@line:  serial line number
  *
  *	Resume one serial port.
  */
 void serial8250_resume_port(int line)
 {
 	struct uart_8250_port *up = &serial8250_ports[line];
 	struct uart_port *port = &up->port;
 	up->canary = 0;
 	if (up->capabilities & UART_NATSEMI) {
 		/* Ensure it's still in high speed mode */
 		serial_port_out(port, UART_LCR, 0xE0);
 		ns16550a_goto_highspeed(up);
 		serial_port_out(port, UART_LCR, 0);
 		port->uartclk = 921600*16;
 	}
 	uart_resume_port(&serial8250_reg, port);
 }
 /*
  * Register a set of serial devices attached to a platform device.  The
  * list is terminated with a zero flags entry, which means we expect
  * all entries to have at least UPF_BOOT_AUTOCONF set.
  */
 static int serial8250_probe(struct platform_device *dev)
 {
 	struct plat_serial8250_port *p = dev_get_platdata(&dev->dev);
 	struct uart_8250_port uart;
 	int ret, i, irqflag = 0;
 	memset(&uart, 0, sizeof(uart));
 	if (share_irqs)
 		irqflag = IRQF_SHARED;
 	for (i = 0; p && p->flags != 0; p++, i++) {
 		uart.port.iobase	= p->iobase;
 		uart.port.membase	= p->membase;
 		uart.port.irq		= p->irq;
 		uart.port.irqflags	= p->irqflags;
 		uart.port.uartclk	= p->uartclk;
 		uart.port.regshift	= p->regshift;
 		uart.port.iotype	= p->iotype;
 		uart.port.flags		= p->flags;
 		uart.port.mapbase	= p->mapbase;
 		uart.port.hub6		= p->hub6;
 		uart.port.private_data	= p->private_data;
 		uart.port.type		= p->type;
 		uart.port.serial_in	= p->serial_in;
 		uart.port.serial_out	= p->serial_out;
 		uart.port.handle_irq	= p->handle_irq;
 		uart.port.handle_break	= p->handle_break;
 		uart.port.set_termios	= p->set_termios;
 		uart.port.pm		= p->pm;
 		uart.port.dev		= &dev->dev;
 		uart.port.irqflags	|= irqflag;
 		ret = serial8250_register_8250_port(&uart);
 		if (ret < 0) {
 			dev_err(&dev->dev, "unable to register port at index %d "
 				"(IO%lx MEM%llx IRQ%d): %d\n", i,
 				p->iobase, (unsigned long long)p->mapbase,
 				p->irq, ret);
 		}
 	}
 	return 0;
 }
 /*
  * Remove serial ports registered against a platform device.
  */
 static int serial8250_remove(struct platform_device *dev)
 {
 	int i;
 	for (i = 0; i < nr_uarts; i++) {
 		struct uart_8250_port *up = &serial8250_ports[i];
 		if (up->port.dev == &dev->dev)
 			serial8250_unregister_port(i);
 	}
 	return 0;
 }
 static int serial8250_suspend(struct platform_device *dev, pm_message_t state)
 {
 	int i;
 	for (i = 0; i < UART_NR; i++) {
 		struct uart_8250_port *up = &serial8250_ports[i];
 		if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
 			uart_suspend_port(&serial8250_reg, &up->port);
 	}
 	return 0;
 }
 static int serial8250_resume(struct platform_device *dev)
 {
 	int i;
 	for (i = 0; i < UART_NR; i++) {
 		struct uart_8250_port *up = &serial8250_ports[i];
 		if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
 			serial8250_resume_port(i);
 	}
 	return 0;
 }
 static struct platform_driver serial8250_isa_driver = {
 	.probe		= serial8250_probe,
 	.remove		= serial8250_remove,
 	.suspend	= serial8250_suspend,
 	.resume		= serial8250_resume,
 	.driver		= {
 		.name	= "serial8250",
 	},
 };
 /*
  * This "device" covers _all_ ISA 8250-compatible serial devices listed
  * in the table in include/asm/serial.h
  */
 static struct platform_device *serial8250_isa_devs;
 /*
  * serial8250_register_8250_port and serial8250_unregister_port allows for
  * 16x50 serial ports to be configured at run-time, to support PCMCIA
  * modems and PCI multiport cards.
  */
 static DEFINE_MUTEX(serial_mutex);
 static struct uart_8250_port *serial8250_find_match_or_unused(struct uart_port *port)
 {
 	int i;
 	/*
 	 * First, find a port entry which matches.
 	 */
 	for (i = 0; i < nr_uarts; i++)
 		if (uart_match_port(&serial8250_ports[i].port, port))
 			return &serial8250_ports[i];
 	/* try line number first if still available */
 	i = port->line;
 	if (i < nr_uarts && serial8250_ports[i].port.type == PORT_UNKNOWN &&
 			serial8250_ports[i].port.iobase == 0)
 		return &serial8250_ports[i];
 	/*
 	 * We didn't find a matching entry, so look for the first
 	 * free entry.  We look for one which hasn't been previously
 	 * used (indicated by zero iobase).
 	 */
 	for (i = 0; i < nr_uarts; i++)
 		if (serial8250_ports[i].port.type == PORT_UNKNOWN &&
 		    serial8250_ports[i].port.iobase == 0)
 			return &serial8250_ports[i];
 	/*
 	 * That also failed.  Last resort is to find any entry which
 	 * doesn't have a real port associated with it.
 	 */
 	for (i = 0; i < nr_uarts; i++)
 		if (serial8250_ports[i].port.type == PORT_UNKNOWN)
 			return &serial8250_ports[i];
 	return NULL;
 }
 /**
  *	serial8250_register_8250_port - register a serial port
  *	@up: serial port template
  *
  *	Configure the serial port specified by the request. If the
  *	port exists and is in use, it is hung up and unregistered
  *	first.
  *
  *	The port is then probed and if necessary the IRQ is autodetected
  *	If this fails an error is returned.
  *
  *	On success the port is ready to use and the line number is returned.
  */
 int serial8250_register_8250_port(struct uart_8250_port *up)
 {
 	struct uart_8250_port *uart;
 	int ret = -ENOSPC;
 	if (up->port.uartclk == 0)
 		return -EINVAL;
 	mutex_lock(&serial_mutex);
 	uart = serial8250_find_match_or_unused(&up->port);
 	if (uart && uart->port.type != PORT_8250_CIR) {
 		if (uart->port.dev)
 			uart_remove_one_port(&serial8250_reg, &uart->port);
 		uart->port.iobase       = up->port.iobase;
 		uart->port.membase      = up->port.membase;
 		uart->port.irq          = up->port.irq;
 		uart->port.irqflags     = up->port.irqflags;
 		uart->port.uartclk      = up->port.uartclk;
 		uart->port.fifosize     = up->port.fifosize;
 		uart->port.regshift     = up->port.regshift;
 		uart->port.iotype       = up->port.iotype;
 		uart->port.flags        = up->port.flags | UPF_BOOT_AUTOCONF;
 		uart->bugs		= up->bugs;
 		uart->port.mapbase      = up->port.mapbase;
 		uart->port.private_data = up->port.private_data;
 		uart->port.fifosize	= up->port.fifosize;
 		uart->tx_loadsz		= up->tx_loadsz;
 		uart->capabilities	= up->capabilities;
 		uart->port.throttle	= up->port.throttle;
 		uart->port.unthrottle	= up->port.unthrottle;
 		uart->port.rs485_config	= up->port.rs485_config;
 		uart->port.rs485	= up->port.rs485;
 		/* Take tx_loadsz from fifosize if it wasn't set separately */
 		if (uart->port.fifosize && !uart->tx_loadsz)
 			uart->tx_loadsz = uart->port.fifosize;
 		if (up->port.dev)
 			uart->port.dev = up->port.dev;
 		if (up->port.flags & UPF_FIXED_TYPE)
 			serial8250_init_fixed_type_port(uart, up->port.type);
 		set_io_from_upio(&uart->port);
 		/* Possibly override default I/O functions.  */
 		if (up->port.serial_in)
 			uart->port.serial_in = up->port.serial_in;
 		if (up->port.serial_out)
 			uart->port.serial_out = up->port.serial_out;
 		if (up->port.handle_irq)
 			uart->port.handle_irq = up->port.handle_irq;
 		/*  Possibly override set_termios call */
 		if (up->port.set_termios)
 			uart->port.set_termios = up->port.set_termios;
 		if (up->port.set_mctrl)
 			uart->port.set_mctrl = up->port.set_mctrl;
 		if (up->port.startup)
 			uart->port.startup = up->port.startup;
 		if (up->port.shutdown)
 			uart->port.shutdown = up->port.shutdown;
 		if (up->port.pm)
 			uart->port.pm = up->port.pm;
 		if (up->port.handle_break)
 			uart->port.handle_break = up->port.handle_break;
 		if (up->dl_read)
 			uart->dl_read = up->dl_read;
 		if (up->dl_write)
 			uart->dl_write = up->dl_write;
 		if (up->dma) {
 			uart->dma = up->dma;
 			if (!uart->dma->tx_dma)
 				uart->dma->tx_dma = serial8250_tx_dma;
 			if (!uart->dma->rx_dma)
 				uart->dma->rx_dma = serial8250_rx_dma;
 		}
 		if (serial8250_isa_config != NULL)
 			serial8250_isa_config(0, &uart->port,
 					&uart->capabilities);
 		ret = uart_add_one_port(&serial8250_reg, &uart->port);
 		if (ret == 0)
 			ret = uart->port.line;
 	}
 	mutex_unlock(&serial_mutex);
 	return ret;
 }
 EXPORT_SYMBOL(serial8250_register_8250_port);
 /**
  *	serial8250_unregister_port - remove a 16x50 serial port at runtime
  *	@line: serial line number
  *
  *	Remove one serial port.  This may not be called from interrupt
  *	context.  We hand the port back to the our control.
  */
 void serial8250_unregister_port(int line)
 {
 	struct uart_8250_port *uart = &serial8250_ports[line];
 	mutex_lock(&serial_mutex);
 	uart_remove_one_port(&serial8250_reg, &uart->port);
 	if (serial8250_isa_devs) {
 		uart->port.flags &= ~UPF_BOOT_AUTOCONF;
 		uart->port.type = PORT_UNKNOWN;
 		uart->port.dev = &serial8250_isa_devs->dev;
 		uart->capabilities = uart_config[uart->port.type].flags;
 		uart_add_one_port(&serial8250_reg, &uart->port);
 	} else {
 		uart->port.dev = NULL;
 	}
 	mutex_unlock(&serial_mutex);
 }
 EXPORT_SYMBOL(serial8250_unregister_port);
 static int __init serial8250_init(void)
 {
 	int ret;
 	serial8250_isa_init_ports();
 	printk(KERN_INFO "Serial: 8250/16550 driver, "
 		"%d ports, IRQ sharing %sabled\n", nr_uarts,
 		share_irqs ? "en" : "dis");
 #ifdef CONFIG_SPARC
 	ret = sunserial_register_minors(&serial8250_reg, UART_NR);
 #else
 	serial8250_reg.nr = UART_NR;
 	ret = uart_register_driver(&serial8250_reg);
 #endif
 	if (ret)
 		goto out;
 	ret = serial8250_pnp_init();
 	if (ret)
 		goto unreg_uart_drv;
 	serial8250_isa_devs = platform_device_alloc("serial8250",
 						    PLAT8250_DEV_LEGACY);
 	if (!serial8250_isa_devs) {
 		ret = -ENOMEM;
 		goto unreg_pnp;
 	}
 	ret = platform_device_add(serial8250_isa_devs);
 	if (ret)
 		goto put_dev;
 	serial8250_register_ports(&serial8250_reg, &serial8250_isa_devs->dev);
 	ret = platform_driver_register(&serial8250_isa_driver);
 	if (ret == 0)
 		goto out;
 	platform_device_del(serial8250_isa_devs);
 put_dev:
 	platform_device_put(serial8250_isa_devs);
 unreg_pnp:
 	serial8250_pnp_exit();
 unreg_uart_drv:
 #ifdef CONFIG_SPARC
 	sunserial_unregister_minors(&serial8250_reg, UART_NR);
 #else
 	uart_unregister_driver(&serial8250_reg);
 #endif
 out:
 	return ret;
 }
 static void __exit serial8250_exit(void)
 {
 	struct platform_device *isa_dev = serial8250_isa_devs;
 	/*
 	 * This tells serial8250_unregister_port() not to re-register
 	 * the ports (thereby making serial8250_isa_driver permanently
 	 * in use.)
 	 */
 	serial8250_isa_devs = NULL;
 	platform_driver_unregister(&serial8250_isa_driver);
 	platform_device_unregister(isa_dev);
 	serial8250_pnp_exit();
 #ifdef CONFIG_SPARC
 	sunserial_unregister_minors(&serial8250_reg, UART_NR);
 #else
 	uart_unregister_driver(&serial8250_reg);
 #endif
 }
 module_init(serial8250_init);
 module_exit(serial8250_exit);
 EXPORT_SYMBOL(serial8250_suspend_port);
 EXPORT_SYMBOL(serial8250_resume_port);
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Generic 8250/16x50 serial driver");
 module_param(share_irqs, uint, 0644);
 MODULE_PARM_DESC(share_irqs, "Share IRQs with other non-8250/16x50 devices"
 	" (unsafe)");
 module_param(nr_uarts, uint, 0644);
 MODULE_PARM_DESC(nr_uarts, "Maximum number of UARTs supported. (1-" __MODULE_STRING(CONFIG_SERIAL_8250_NR_UARTS) ")");
 module_param(skip_txen_test, uint, 0644);
 MODULE_PARM_DESC(skip_txen_test, "Skip checking for the TXEN bug at init time");
 #ifdef CONFIG_SERIAL_8250_RSA
 module_param_array(probe_rsa, ulong, &probe_rsa_count, 0444);
 MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA");
 #endif
 MODULE_ALIAS_CHARDEV_MAJOR(TTY_MAJOR);
 #ifdef CONFIG_SERIAL_8250_DEPRECATED_OPTIONS
 #ifndef MODULE
 /* This module was renamed to 8250_core in 3.7.  Keep the old "8250" name
  * working as well for the module options so we don't break people.  We
  * need to keep the names identical and the convenient macros will happily
  * refuse to let us do that by failing the build with redefinition errors
  * of global variables.  So we stick them inside a dummy function to avoid
  * those conflicts.  The options still get parsed, and the redefined
  * MODULE_PARAM_PREFIX lets us keep the "8250." syntax alive.
  *
  * This is hacky.  I'm sorry.
  */
 static void __used s8250_options(void)
 {
 #undef MODULE_PARAM_PREFIX
 #define MODULE_PARAM_PREFIX "8250_core."
 	module_param_cb(share_irqs, &param_ops_uint, &share_irqs, 0644);
 	module_param_cb(nr_uarts, &param_ops_uint, &nr_uarts, 0644);
 	module_param_cb(skip_txen_test, &param_ops_uint, &skip_txen_test, 0644);
 #ifdef CONFIG_SERIAL_8250_RSA
 	__module_param_call(MODULE_PARAM_PREFIX, probe_rsa,
 		&param_array_ops, .arr = &__param_arr_probe_rsa,
 		0444, -1, 0);
 #endif
 }
 #else
 MODULE_ALIAS("8250_core");
 #endif
 #endif

drivers/tty/serial/8250/8250_dw.c

Diff comments View file @ bbbce51

 /*
  * Synopsys DesignWare 8250 driver.
  *
  * Copyright 2011 Picochip, Jamie Iles.
  * Copyright 2013 Intel Corporation
  *
  * 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.
  *
  * The Synopsys DesignWare 8250 has an extra feature whereby it detects if the
  * LCR is written whilst busy.  If it is, then a busy detect interrupt is
  * raised, the LCR needs to be rewritten and the uart status register read.
  */
 #include <linux/device.h>
 #include <linux/io.h>
 #include <linux/module.h>
 #include <linux/serial_8250.h>
 #include <linux/serial_core.h>
 #include <linux/serial_reg.h>
 #include <linux/of.h>
 #include <linux/of_irq.h>
 #include <linux/of_platform.h>
 #include <linux/platform_device.h>
 #include <linux/slab.h>
 #include <linux/acpi.h>
 #include <linux/clk.h>
 #include <linux/reset.h>
 #include <linux/pm_runtime.h>
 #include <asm/byteorder.h>
 #include "8250.h"
 /* Offsets for the DesignWare specific registers */
 #define DW_UART_USR	0x1f /* UART Status Register */
 #define DW_UART_CPR	0xf4 /* Component Parameter Register */
 #define DW_UART_UCV	0xf8 /* UART Component Version */
 /* Component Parameter Register bits */
 #define DW_UART_CPR_ABP_DATA_WIDTH	(3 << 0)
 #define DW_UART_CPR_AFCE_MODE		(1 << 4)
 #define DW_UART_CPR_THRE_MODE		(1 << 5)
 #define DW_UART_CPR_SIR_MODE		(1 << 6)
 #define DW_UART_CPR_SIR_LP_MODE		(1 << 7)
 #define DW_UART_CPR_ADDITIONAL_FEATURES	(1 << 8)
 #define DW_UART_CPR_FIFO_ACCESS		(1 << 9)
 #define DW_UART_CPR_FIFO_STAT		(1 << 10)
 #define DW_UART_CPR_SHADOW		(1 << 11)
 #define DW_UART_CPR_ENCODED_PARMS	(1 << 12)
 #define DW_UART_CPR_DMA_EXTRA		(1 << 13)
 #define DW_UART_CPR_FIFO_MODE		(0xff << 16)
 /* Helper for fifo size calculation */
 #define DW_UART_CPR_FIFO_SIZE(a)	(((a >> 16) & 0xff) * 16)
 struct dw8250_data {
 	u8			usr_reg;
 	int			last_mcr;
 	int			line;
+	int			msr_mask_on;
+	int			msr_mask_off;
 	struct clk		*clk;
 	struct clk		*pclk;
 	struct reset_control	*rst;
 	struct uart_8250_dma	dma;
 };
 #define BYT_PRV_CLK			0x800
 #define BYT_PRV_CLK_EN			(1 << 0)
 #define BYT_PRV_CLK_M_VAL_SHIFT		1
 #define BYT_PRV_CLK_N_VAL_SHIFT		16
 #define BYT_PRV_CLK_UPDATE		(1 << 31)
 static inline int dw8250_modify_msr(struct uart_port *p, int offset, int value)
 {
 	struct dw8250_data *d = p->private_data;
 	/* If reading MSR, report CTS asserted when auto-CTS/RTS enabled */
 	if (offset == UART_MSR && d->last_mcr & UART_MCR_AFE) {
 		value |= UART_MSR_CTS;
 		value &= ~UART_MSR_DCTS;
 	}
+	/* Override any modem control signals if needed */
+	if (offset == UART_MSR) {
+		value |= d->msr_mask_on;
+		value &= ~d->msr_mask_off;
+	}
 	return value;
 }
 static void dw8250_force_idle(struct uart_port *p)
 {
 	struct uart_8250_port *up = up_to_u8250p(p);
 	serial8250_clear_and_reinit_fifos(up);
 	(void)p->serial_in(p, UART_RX);
 }
 static void dw8250_serial_out(struct uart_port *p, int offset, int value)
 {
 	struct dw8250_data *d = p->private_data;
 	if (offset == UART_MCR)
 		d->last_mcr = value;
 	writeb(value, p->membase + (offset << p->regshift));
 	/* Make sure LCR write wasn't ignored */
 	if (offset == UART_LCR) {
 		int tries = 1000;
 		while (tries--) {
 			unsigned int lcr = p->serial_in(p, UART_LCR);
 			if ((value & ~UART_LCR_SPAR) == (lcr & ~UART_LCR_SPAR))
 				return;
 			dw8250_force_idle(p);
 			writeb(value, p->membase + (UART_LCR << p->regshift));
 		}
 		dev_err(p->dev, "Couldn't set LCR to %d\n", value);
 	}
 }
 static unsigned int dw8250_serial_in(struct uart_port *p, int offset)
 {
 	unsigned int value = readb(p->membase + (offset << p->regshift));
 	return dw8250_modify_msr(p, offset, value);
 }
 #ifdef CONFIG_64BIT
 static unsigned int dw8250_serial_inq(struct uart_port *p, int offset)
 {
 	unsigned int value;
 	value = (u8)__raw_readq(p->membase + (offset << p->regshift));
 	return dw8250_modify_msr(p, offset, value);
 }
 static void dw8250_serial_outq(struct uart_port *p, int offset, int value)
 {
 	struct dw8250_data *d = p->private_data;
 	if (offset == UART_MCR)
 		d->last_mcr = value;
 	value &= 0xff;
 	__raw_writeq(value, p->membase + (offset << p->regshift));
 	/* Read back to ensure register write ordering. */
 	__raw_readq(p->membase + (UART_LCR << p->regshift));
 	/* Make sure LCR write wasn't ignored */
 	if (offset == UART_LCR) {
 		int tries = 1000;
 		while (tries--) {
 			unsigned int lcr = p->serial_in(p, UART_LCR);
 			if ((value & ~UART_LCR_SPAR) == (lcr & ~UART_LCR_SPAR))
 				return;
 			dw8250_force_idle(p);
 			__raw_writeq(value & 0xff,
 				     p->membase + (UART_LCR << p->regshift));
 		}
 		dev_err(p->dev, "Couldn't set LCR to %d\n", value);
 	}
 }
 #endif /* CONFIG_64BIT */
 static void dw8250_serial_out32(struct uart_port *p, int offset, int value)
 {
 	struct dw8250_data *d = p->private_data;
 	if (offset == UART_MCR)
 		d->last_mcr = value;
 	writel(value, p->membase + (offset << p->regshift));
 	/* Make sure LCR write wasn't ignored */
 	if (offset == UART_LCR) {
 		int tries = 1000;
 		while (tries--) {
 			unsigned int lcr = p->serial_in(p, UART_LCR);
 			if ((value & ~UART_LCR_SPAR) == (lcr & ~UART_LCR_SPAR))
 				return;
 			dw8250_force_idle(p);
 			writel(value, p->membase + (UART_LCR << p->regshift));
 		}
 		dev_err(p->dev, "Couldn't set LCR to %d\n", value);
 	}
 }
 static unsigned int dw8250_serial_in32(struct uart_port *p, int offset)
 {
 	unsigned int value = readl(p->membase + (offset << p->regshift));
 	return dw8250_modify_msr(p, offset, value);
 }
 static int dw8250_handle_irq(struct uart_port *p)
 {
 	struct dw8250_data *d = p->private_data;
 	unsigned int iir = p->serial_in(p, UART_IIR);
 	if (serial8250_handle_irq(p, iir)) {
 		return 1;
 	} else if ((iir & UART_IIR_BUSY) == UART_IIR_BUSY) {
 		/* Clear the USR */
 		(void)p->serial_in(p, d->usr_reg);
 		return 1;
 	}
 	return 0;
 }
 static void
 dw8250_do_pm(struct uart_port *port, unsigned int state, unsigned int old)
 {
 	if (!state)
 		pm_runtime_get_sync(port->dev);
 	serial8250_do_pm(port, state, old);
 	if (state)
 		pm_runtime_put_sync_suspend(port->dev);
 }
 static void dw8250_set_termios(struct uart_port *p, struct ktermios *termios,
 			       struct ktermios *old)
 {
 	unsigned int baud = tty_termios_baud_rate(termios);
 	struct dw8250_data *d = p->private_data;
 	unsigned int rate;
 	int ret;
 	if (IS_ERR(d->clk) || !old)
 		goto out;
 	/* Not requesting clock rates below 1.8432Mhz */
 	if (baud < 115200)
 		baud = 115200;
 	clk_disable_unprepare(d->clk);
 	rate = clk_round_rate(d->clk, baud * 16);
 	ret = clk_set_rate(d->clk, rate);
 	clk_prepare_enable(d->clk);
 	if (!ret)
 		p->uartclk = rate;
 out:
 	serial8250_do_set_termios(p, termios, old);
 }
 static bool dw8250_dma_filter(struct dma_chan *chan, void *param)
 {
 	return false;
 }
 static void dw8250_setup_port(struct uart_8250_port *up)
 {
 	struct uart_port	*p = &up->port;
 	u32			reg = readl(p->membase + DW_UART_UCV);
 	/*
 	 * If the Component Version Register returns zero, we know that
 	 * ADDITIONAL_FEATURES are not enabled. No need to go any further.
 	 */
 	if (!reg)
 		return;
 	dev_dbg_ratelimited(p->dev, "Designware UART version %c.%c%c\n",
 		(reg >> 24) & 0xff, (reg >> 16) & 0xff, (reg >> 8) & 0xff);
 	reg = readl(p->membase + DW_UART_CPR);
 	if (!reg)
 		return;
 	/* Select the type based on fifo */
 	if (reg & DW_UART_CPR_FIFO_MODE) {
 		p->type = PORT_16550A;
 		p->flags |= UPF_FIXED_TYPE;
 		p->fifosize = DW_UART_CPR_FIFO_SIZE(reg);
 		up->tx_loadsz = p->fifosize;
 		up->capabilities = UART_CAP_FIFO;
 	}
 	if (reg & DW_UART_CPR_AFCE_MODE)
 		up->capabilities |= UART_CAP_AFE;
 }
 static int dw8250_probe_of(struct uart_port *p,
 			   struct dw8250_data *data)
 {
 	struct device_node	*np = p->dev->of_node;
 	struct uart_8250_port *up = up_to_u8250p(p);
 	u32			val;
 	bool has_ucv = true;
 	int id;
 #ifdef CONFIG_64BIT
 	if (of_device_is_compatible(np, "cavium,octeon-3860-uart")) {
 		p->serial_in = dw8250_serial_inq;
 		p->serial_out = dw8250_serial_outq;
 		p->flags = UPF_SKIP_TEST | UPF_SHARE_IRQ | UPF_FIXED_TYPE;
 		p->type = PORT_OCTEON;
 		data->usr_reg = 0x27;
 		has_ucv = false;
 	} else
 #endif
 	if (!of_property_read_u32(np, "reg-io-width", &val)) {
 		switch (val) {
 		case 1:
 			break;
 		case 4:
 			p->iotype = UPIO_MEM32;
 			p->serial_in = dw8250_serial_in32;
 			p->serial_out = dw8250_serial_out32;
 			break;
 		default:
 			dev_err(p->dev, "unsupported reg-io-width (%u)\n", val);
 			return -EINVAL;
 		}
 	}
 	if (has_ucv)
 		dw8250_setup_port(up);
 	/* if we have a valid fifosize, try hooking up DMA here */
 	if (p->fifosize) {
 		up->dma = &data->dma;
 		up->dma->rxconf.src_maxburst = p->fifosize / 4;
 		up->dma->txconf.dst_maxburst = p->fifosize / 4;
 	}
 	if (!of_property_read_u32(np, "reg-shift", &val))
 		p->regshift = val;
 	/* get index of serial line, if found in DT aliases */
 	id = of_alias_get_id(np, "serial");
 	if (id >= 0)
 		p->line = id;
+	if (of_property_read_bool(np, "dcd-override")) {
+		/* Always report DCD as active */
+		data->msr_mask_on |= UART_MSR_DCD;
+		data->msr_mask_off |= UART_MSR_DDCD;
+	}
+	if (of_property_read_bool(np, "dsr-override")) {
+		/* Always report DSR as active */
+		data->msr_mask_on |= UART_MSR_DSR;
+		data->msr_mask_off |= UART_MSR_DDSR;
+	}
+	if (of_property_read_bool(np, "cts-override")) {
+		/* Always report DSR as active */
+		data->msr_mask_on |= UART_MSR_DSR;
+		data->msr_mask_off |= UART_MSR_DDSR;
+	}
+	if (of_property_read_bool(np, "ri-override")) {
+		/* Always report Ring indicator as inactive */
+		data->msr_mask_off |= UART_MSR_RI;
+		data->msr_mask_off |= UART_MSR_TERI;
+	}
 	/* clock got configured through clk api, all done */
 	if (p->uartclk)
 		return 0;
 	/* try to find out clock frequency from DT as fallback */
 	if (of_property_read_u32(np, "clock-frequency", &val)) {
 		dev_err(p->dev, "clk or clock-frequency not defined\n");
 		return -EINVAL;
 	}
 	p->uartclk = val;
 	return 0;
 }
 static int dw8250_probe_acpi(struct uart_8250_port *up,
 			     struct dw8250_data *data)
 {
 	const struct acpi_device_id *id;
 	struct uart_port *p = &up->port;
 	dw8250_setup_port(up);
 	id = acpi_match_device(p->dev->driver->acpi_match_table, p->dev);
 	if (!id)
 		return -ENODEV;
 	if (!p->uartclk)
 		if (device_property_read_u32(p->dev, "clock-frequency",
 					     &p->uartclk))
 			return -EINVAL;
 	p->iotype = UPIO_MEM32;
 	p->serial_in = dw8250_serial_in32;
 	p->serial_out = dw8250_serial_out32;
 	p->regshift = 2;
 	up->dma = &data->dma;
 	up->dma->rxconf.src_maxburst = p->fifosize / 4;
 	up->dma->txconf.dst_maxburst = p->fifosize / 4;
 	up->port.set_termios = dw8250_set_termios;
 	return 0;
 }
 static int dw8250_probe(struct platform_device *pdev)
 {
 	struct uart_8250_port uart = {};
 	struct resource *regs = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	struct resource *irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
 	struct dw8250_data *data;
 	int err;
 	if (!regs || !irq) {
 		dev_err(&pdev->dev, "no registers/irq defined\n");
 		return -EINVAL;
 	}
 	spin_lock_init(&uart.port.lock);
 	uart.port.mapbase = regs->start;
 	uart.port.irq = irq->start;
 	uart.port.handle_irq = dw8250_handle_irq;
 	uart.port.pm = dw8250_do_pm;
 	uart.port.type = PORT_8250;
 	uart.port.flags = UPF_SHARE_IRQ | UPF_BOOT_AUTOCONF | UPF_FIXED_PORT;
 	uart.port.dev = &pdev->dev;
 	uart.port.membase = devm_ioremap(&pdev->dev, regs->start,
 					 resource_size(regs));
 	if (!uart.port.membase)
 		return -ENOMEM;
 	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
 	if (!data)
 		return -ENOMEM;
 	data->usr_reg = DW_UART_USR;
 	data->clk = devm_clk_get(&pdev->dev, "baudclk");
 	if (IS_ERR(data->clk) && PTR_ERR(data->clk) != -EPROBE_DEFER)
 		data->clk = devm_clk_get(&pdev->dev, NULL);
 	if (IS_ERR(data->clk) && PTR_ERR(data->clk) == -EPROBE_DEFER)
 		return -EPROBE_DEFER;
 	if (!IS_ERR(data->clk)) {
 		err = clk_prepare_enable(data->clk);
 		if (err)
 			dev_warn(&pdev->dev, "could not enable optional baudclk: %d\n",
 				 err);
 		else
 			uart.port.uartclk = clk_get_rate(data->clk);
 	}
 	data->pclk = devm_clk_get(&pdev->dev, "apb_pclk");
 	if (IS_ERR(data->clk) && PTR_ERR(data->clk) == -EPROBE_DEFER) {
 		err = -EPROBE_DEFER;
 		goto err_clk;
 	}
 	if (!IS_ERR(data->pclk)) {
 		err = clk_prepare_enable(data->pclk);
 		if (err) {
 			dev_err(&pdev->dev, "could not enable apb_pclk\n");
 			goto err_clk;
 		}
 	}
 	data->rst = devm_reset_control_get_optional(&pdev->dev, NULL);
 	if (IS_ERR(data->rst) && PTR_ERR(data->rst) == -EPROBE_DEFER) {
 		err = -EPROBE_DEFER;
 		goto err_pclk;
 	}
 	if (!IS_ERR(data->rst))
 		reset_control_deassert(data->rst);
 	data->dma.rx_param = data;
 	data->dma.tx_param = data;
 	data->dma.fn = dw8250_dma_filter;
 	uart.port.iotype = UPIO_MEM;
 	uart.port.serial_in = dw8250_serial_in;
 	uart.port.serial_out = dw8250_serial_out;
 	uart.port.private_data = data;
 	if (pdev->dev.of_node) {
 		err = dw8250_probe_of(&uart.port, data);
 		if (err)
 			goto err_reset;
 	} else if (ACPI_HANDLE(&pdev->dev)) {
 		err = dw8250_probe_acpi(&uart, data);
 		if (err)
 			goto err_reset;
 	} else {
 		err = -ENODEV;
 		goto err_reset;
 	}
 	data->line = serial8250_register_8250_port(&uart);
 	if (data->line < 0) {
 		err = data->line;
 		goto err_reset;
 	}
 	platform_set_drvdata(pdev, data);
 	pm_runtime_set_active(&pdev->dev);
 	pm_runtime_enable(&pdev->dev);
 	return 0;
 err_reset:
 	if (!IS_ERR(data->rst))
 		reset_control_assert(data->rst);
 err_pclk:
 	if (!IS_ERR(data->pclk))
 		clk_disable_unprepare(data->pclk);
 err_clk:
 	if (!IS_ERR(data->clk))
 		clk_disable_unprepare(data->clk);
 	return err;
 }
 static int dw8250_remove(struct platform_device *pdev)
 {
 	struct dw8250_data *data = platform_get_drvdata(pdev);
 	pm_runtime_get_sync(&pdev->dev);
 	serial8250_unregister_port(data->line);
 	if (!IS_ERR(data->rst))
 		reset_control_assert(data->rst);
 	if (!IS_ERR(data->pclk))
 		clk_disable_unprepare(data->pclk);
 	if (!IS_ERR(data->clk))
 		clk_disable_unprepare(data->clk);
 	pm_runtime_disable(&pdev->dev);
 	pm_runtime_put_noidle(&pdev->dev);
 	return 0;
 }
 #ifdef CONFIG_PM_SLEEP
 static int dw8250_suspend(struct device *dev)
 {
 	struct dw8250_data *data = dev_get_drvdata(dev);
 	serial8250_suspend_port(data->line);
 	return 0;
 }
 static int dw8250_resume(struct device *dev)
 {
 	struct dw8250_data *data = dev_get_drvdata(dev);
 	serial8250_resume_port(data->line);
 	return 0;
 }
 #endif /* CONFIG_PM_SLEEP */
 #ifdef CONFIG_PM
 static int dw8250_runtime_suspend(struct device *dev)
 {
 	struct dw8250_data *data = dev_get_drvdata(dev);
 	if (!IS_ERR(data->clk))
 		clk_disable_unprepare(data->clk);
 	if (!IS_ERR(data->pclk))
 		clk_disable_unprepare(data->pclk);
 	return 0;
 }
 static int dw8250_runtime_resume(struct device *dev)
 {
 	struct dw8250_data *data = dev_get_drvdata(dev);
 	if (!IS_ERR(data->pclk))
 		clk_prepare_enable(data->pclk);
 	if (!IS_ERR(data->clk))
 		clk_prepare_enable(data->clk);
 	return 0;
 }
 #endif
 static const struct dev_pm_ops dw8250_pm_ops = {
 	SET_SYSTEM_SLEEP_PM_OPS(dw8250_suspend, dw8250_resume)
 	SET_RUNTIME_PM_OPS(dw8250_runtime_suspend, dw8250_runtime_resume, NULL)
 };
 static const struct of_device_id dw8250_of_match[] = {
 	{ .compatible = "snps,dw-apb-uart" },
 	{ .compatible = "cavium,octeon-3860-uart" },
 	{ /* Sentinel */ }
 };
 MODULE_DEVICE_TABLE(of, dw8250_of_match);
 static const struct acpi_device_id dw8250_acpi_match[] = {
 	{ "INT33C4", 0 },
 	{ "INT33C5", 0 },
 	{ "INT3434", 0 },
 	{ "INT3435", 0 },
 	{ "80860F0A", 0 },
 	{ "8086228A", 0 },
 	{ "APMC0D08", 0},
 	{ },
 };
 MODULE_DEVICE_TABLE(acpi, dw8250_acpi_match);
 static struct platform_driver dw8250_platform_driver = {
 	.driver = {
 		.name		= "dw-apb-uart",
 		.pm		= &dw8250_pm_ops,
 		.of_match_table	= dw8250_of_match,
 		.acpi_match_table = ACPI_PTR(dw8250_acpi_match),
 	},
 	.probe			= dw8250_probe,
 	.remove			= dw8250_remove,
 };
 module_platform_driver(dw8250_platform_driver);
 MODULE_AUTHOR("Jamie Iles");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Synopsys DesignWare 8250 serial port driver");

drivers/tty/serial/8250/8250_pci.c

Diff comments View file @ bbbce51

 /*
  *  Probe module for 8250/16550-type PCI serial ports.
  *
  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
  *
  *  Copyright (C) 2001 Russell King, All Rights Reserved.
  *
  * 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.
  */
 #undef DEBUG
 #include <linux/module.h>
 #include <linux/pci.h>
 #include <linux/string.h>
 #include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/tty.h>
 #include <linux/serial_reg.h>
 #include <linux/serial_core.h>
 #include <linux/8250_pci.h>
 #include <linux/bitops.h>
 #include <asm/byteorder.h>
 #include <asm/io.h>
 #include <linux/dmaengine.h>
 #include <linux/platform_data/dma-dw.h>
 #include "8250.h"
 /*
  * init function returns:
  *  > 0 - number of ports
  *  = 0 - use board->num_ports
  *  < 0 - error
  */
 struct pci_serial_quirk {
 	u32	vendor;
 	u32	device;
 	u32	subvendor;
 	u32	subdevice;
 	int	(*probe)(struct pci_dev *dev);
 	int	(*init)(struct pci_dev *dev);
 	int	(*setup)(struct serial_private *,
 			 const struct pciserial_board *,
 			 struct uart_8250_port *, int);
 	void	(*exit)(struct pci_dev *dev);
 };
 #define PCI_NUM_BAR_RESOURCES	6
 struct serial_private {
 	struct pci_dev		*dev;
 	unsigned int		nr;
 	void __iomem		*remapped_bar[PCI_NUM_BAR_RESOURCES];
 	struct pci_serial_quirk	*quirk;
 	int			line[0];
 };
 static int pci_default_setup(struct serial_private*,
 	  const struct pciserial_board*, struct uart_8250_port *, int);
 static void moan_device(const char *str, struct pci_dev *dev)
 {
 	dev_err(&dev->dev,
 	       "%s: %s\n"
 	       "Please send the output of lspci -vv, this\n"
 	       "message (0x%04x,0x%04x,0x%04x,0x%04x), the\n"
 	       "manufacturer and name of serial board or\n"
-	       "modem board to rmk+serial@arm.linux.org.uk.\n",
+	       "modem board to <linux-serial@vger.kernel.org>.\n",
 	       pci_name(dev), str, dev->vendor, dev->device,
 	       dev->subsystem_vendor, dev->subsystem_device);
 }
 static int
 setup_port(struct serial_private *priv, struct uart_8250_port *port,
 	   int bar, int offset, int regshift)
 {
 	struct pci_dev *dev = priv->dev;
 	if (bar >= PCI_NUM_BAR_RESOURCES)
 		return -EINVAL;
 	if (pci_resource_flags(dev, bar) & IORESOURCE_MEM) {
 		if (!priv->remapped_bar[bar])
 			priv->remapped_bar[bar] = pci_ioremap_bar(dev, bar);
 		if (!priv->remapped_bar[bar])
 			return -ENOMEM;
 		port->port.iotype = UPIO_MEM;
 		port->port.iobase = 0;
 		port->port.mapbase = pci_resource_start(dev, bar) + offset;
 		port->port.membase = priv->remapped_bar[bar] + offset;
 		port->port.regshift = regshift;
 	} else {
 		port->port.iotype = UPIO_PORT;
 		port->port.iobase = pci_resource_start(dev, bar) + offset;
 		port->port.mapbase = 0;
 		port->port.membase = NULL;
 		port->port.regshift = 0;
 	}
 	return 0;
 }
 /*
  * ADDI-DATA GmbH communication cards <info@addi-data.com>
  */
 static int addidata_apci7800_setup(struct serial_private *priv,
 				const struct pciserial_board *board,
 				struct uart_8250_port *port, int idx)
 {
 	unsigned int bar = 0, offset = board->first_offset;
 	bar = FL_GET_BASE(board->flags);
 	if (idx < 2) {
 		offset += idx * board->uart_offset;
 	} else if ((idx >= 2) && (idx < 4)) {
 		bar += 1;
 		offset += ((idx - 2) * board->uart_offset);
 	} else if ((idx >= 4) && (idx < 6)) {
 		bar += 2;
 		offset += ((idx - 4) * board->uart_offset);
 	} else if (idx >= 6) {
 		bar += 3;
 		offset += ((idx - 6) * board->uart_offset);
 	}
 	return setup_port(priv, port, bar, offset, board->reg_shift);
 }
 /*
  * AFAVLAB uses a different mixture of BARs and offsets
  * Not that ugly ;) -- HW
  */
 static int
 afavlab_setup(struct serial_private *priv, const struct pciserial_board *board,
 	      struct uart_8250_port *port, int idx)
 {
 	unsigned int bar, offset = board->first_offset;
 	bar = FL_GET_BASE(board->flags);
 	if (idx < 4)
 		bar += idx;
 	else {
 		bar = 4;
 		offset += (idx - 4) * board->uart_offset;
 	}
 	return setup_port(priv, port, bar, offset, board->reg_shift);
 }
 /*
  * HP's Remote Management Console.  The Diva chip came in several
  * different versions.  N-class, L2000 and A500 have two Diva chips, each
  * with 3 UARTs (the third UART on the second chip is unused).  Superdome
  * and Keystone have one Diva chip with 3 UARTs.  Some later machines have
  * one Diva chip, but it has been expanded to 5 UARTs.
  */
 static int pci_hp_diva_init(struct pci_dev *dev)
 {
 	int rc = 0;
 	switch (dev->subsystem_device) {
 	case PCI_DEVICE_ID_HP_DIVA_TOSCA1:
 	case PCI_DEVICE_ID_HP_DIVA_HALFDOME:
 	case PCI_DEVICE_ID_HP_DIVA_KEYSTONE:
 	case PCI_DEVICE_ID_HP_DIVA_EVEREST:
 		rc = 3;
 		break;
 	case PCI_DEVICE_ID_HP_DIVA_TOSCA2:
 		rc = 2;
 		break;
 	case PCI_DEVICE_ID_HP_DIVA_MAESTRO:
 		rc = 4;
 		break;
 	case PCI_DEVICE_ID_HP_DIVA_POWERBAR:
 	case PCI_DEVICE_ID_HP_DIVA_HURRICANE:
 		rc = 1;
 		break;
 	}
 	return rc;
 }
 /*
  * HP's Diva chip puts the 4th/5th serial port further out, and
  * some serial ports are supposed to be hidden on certain models.
  */
 static int
 pci_hp_diva_setup(struct serial_private *priv,
 		const struct pciserial_board *board,
 		struct uart_8250_port *port, int idx)
 {
 	unsigned int offset = board->first_offset;
 	unsigned int bar = FL_GET_BASE(board->flags);
 	switch (priv->dev->subsystem_device) {
 	case PCI_DEVICE_ID_HP_DIVA_MAESTRO:
 		if (idx == 3)
 			idx++;
 		break;
 	case PCI_DEVICE_ID_HP_DIVA_EVEREST:
 		if (idx > 0)
 			idx++;
 		if (idx > 2)
 			idx++;
 		break;
 	}
 	if (idx > 2)
 		offset = 0x18;
 	offset += idx * board->uart_offset;
 	return setup_port(priv, port, bar, offset, board->reg_shift);
 }
 /*
  * Added for EKF Intel i960 serial boards
  */
 static int pci_inteli960ni_init(struct pci_dev *dev)
 {
 	u32 oldval;
 	if (!(dev->subsystem_device & 0x1000))
 		return -ENODEV;
 	/* is firmware started? */
 	pci_read_config_dword(dev, 0x44, &oldval);
 	if (oldval == 0x00001000L) { /* RESET value */
 		dev_dbg(&dev->dev, "Local i960 firmware missing\n");
 		return -ENODEV;
 	}
 	return 0;
 }
 /*
  * Some PCI serial cards using the PLX 9050 PCI interface chip require
  * that the card interrupt be explicitly enabled or disabled.  This
  * seems to be mainly needed on card using the PLX which also use I/O
  * mapped memory.
  */
 static int pci_plx9050_init(struct pci_dev *dev)
 {
 	u8 irq_config;
 	void __iomem *p;
 	if ((pci_resource_flags(dev, 0) & IORESOURCE_MEM) == 0) {
 		moan_device("no memory in bar 0", dev);
 		return 0;
 	}
 	irq_config = 0x41;
 	if (dev->vendor == PCI_VENDOR_ID_PANACOM ||
 	    dev->subsystem_vendor == PCI_SUBVENDOR_ID_EXSYS)
 		irq_config = 0x43;
 	if ((dev->vendor == PCI_VENDOR_ID_PLX) &&
 	    (dev->device == PCI_DEVICE_ID_PLX_ROMULUS))
 		/*
 		 * As the megawolf cards have the int pins active
 		 * high, and have 2 UART chips, both ints must be
 		 * enabled on the 9050. Also, the UARTS are set in
 		 * 16450 mode by default, so we have to enable the
 		 * 16C950 'enhanced' mode so that we can use the
 		 * deep FIFOs
 		 */
 		irq_config = 0x5b;
 	/*
 	 * enable/disable interrupts
 	 */
 	p = ioremap_nocache(pci_resource_start(dev, 0), 0x80);
 	if (p == NULL)
 		return -ENOMEM;
 	writel(irq_config, p + 0x4c);
 	/*
 	 * Read the register back to ensure that it took effect.
 	 */
 	readl(p + 0x4c);
 	iounmap(p);
 	return 0;
 }
 static void pci_plx9050_exit(struct pci_dev *dev)
 {
 	u8 __iomem *p;
 	if ((pci_resource_flags(dev, 0) & IORESOURCE_MEM) == 0)
 		return;
 	/*
 	 * disable interrupts
 	 */
 	p = ioremap_nocache(pci_resource_start(dev, 0), 0x80);
 	if (p != NULL) {
 		writel(0, p + 0x4c);
 		/*
 		 * Read the register back to ensure that it took effect.
 		 */
 		readl(p + 0x4c);
 		iounmap(p);
 	}
 }
 #define NI8420_INT_ENABLE_REG	0x38
 #define NI8420_INT_ENABLE_BIT	0x2000
 static void pci_ni8420_exit(struct pci_dev *dev)
 {
 	void __iomem *p;
 	unsigned int bar = 0;
 	if ((pci_resource_flags(dev, bar) & IORESOURCE_MEM) == 0) {
 		moan_device("no memory in bar", dev);
 		return;
 	}
 	p = pci_ioremap_bar(dev, bar);
 	if (p == NULL)
 		return;
 	/* Disable the CPU Interrupt */
 	writel(readl(p + NI8420_INT_ENABLE_REG) & ~(NI8420_INT_ENABLE_BIT),
 	       p + NI8420_INT_ENABLE_REG);
 	iounmap(p);
 }
 /* MITE registers */
 #define MITE_IOWBSR1	0xc4
 #define MITE_IOWCR1	0xf4
 #define MITE_LCIMR1	0x08
 #define MITE_LCIMR2	0x10
 #define MITE_LCIMR2_CLR_CPU_IE	(1 << 30)
 static void pci_ni8430_exit(struct pci_dev *dev)
 {
 	void __iomem *p;
 	unsigned int bar = 0;
 	if ((pci_resource_flags(dev, bar) & IORESOURCE_MEM) == 0) {
 		moan_device("no memory in bar", dev);
 		return;
 	}
 	p = pci_ioremap_bar(dev, bar);
 	if (p == NULL)
 		return;
 	/* Disable the CPU Interrupt */
 	writel(MITE_LCIMR2_CLR_CPU_IE, p + MITE_LCIMR2);
 	iounmap(p);
 }
 /* SBS Technologies Inc. PMC-OCTPRO and P-OCTAL cards */
 static int
 sbs_setup(struct serial_private *priv, const struct pciserial_board *board,
 		struct uart_8250_port *port, int idx)
 {
 	unsigned int bar, offset = board->first_offset;
 	bar = 0;
 	if (idx < 4) {
 		/* first four channels map to 0, 0x100, 0x200, 0x300 */
 		offset += idx * board->uart_offset;
 	} else if (idx < 8) {
 		/* last four channels map to 0x1000, 0x1100, 0x1200, 0x1300 */
 		offset += idx * board->uart_offset + 0xC00;
 	} else /* we have only 8 ports on PMC-OCTALPRO */
 		return 1;
 	return setup_port(priv, port, bar, offset, board->reg_shift);
 }
 /*
 * This does initialization for PMC OCTALPRO cards:
 * maps the device memory, resets the UARTs (needed, bc
 * if the module is removed and inserted again, the card
 * is in the sleep mode) and enables global interrupt.
 */
 /* global control register offset for SBS PMC-OctalPro */
 #define OCT_REG_CR_OFF		0x500
 static int sbs_init(struct pci_dev *dev)
 {
 	u8 __iomem *p;
 	p = pci_ioremap_bar(dev, 0);
 	if (p == NULL)
 		return -ENOMEM;
 	/* Set bit-4 Control Register (UART RESET) in to reset the uarts */
 	writeb(0x10, p + OCT_REG_CR_OFF);
 	udelay(50);
 	writeb(0x0, p + OCT_REG_CR_OFF);
 	/* Set bit-2 (INTENABLE) of Control Register */
 	writeb(0x4, p + OCT_REG_CR_OFF);
 	iounmap(p);
 	return 0;
 }
 /*
  * Disables the global interrupt of PMC-OctalPro
  */
 static void sbs_exit(struct pci_dev *dev)
 {
 	u8 __iomem *p;
 	p = pci_ioremap_bar(dev, 0);
 	/* FIXME: What if resource_len < OCT_REG_CR_OFF */
 	if (p != NULL)
 		writeb(0, p + OCT_REG_CR_OFF);
 	iounmap(p);
 }
 /*
  * SIIG serial cards have an PCI interface chip which also controls
  * the UART clocking frequency. Each UART can be clocked independently
  * (except cards equipped with 4 UARTs) and initial clocking settings
  * are stored in the EEPROM chip. It can cause problems because this
  * version of serial driver doesn't support differently clocked UART's
  * on single PCI card. To prevent this, initialization functions set
  * high frequency clocking for all UART's on given card. It is safe (I
  * hope) because it doesn't touch EEPROM settings to prevent conflicts
  * with other OSes (like M$ DOS).
  *
  *  SIIG support added by Andrey Panin <pazke@donpac.ru>, 10/1999
  *
  * There is two family of SIIG serial cards with different PCI
  * interface chip and different configuration methods:
  *     - 10x cards have control registers in IO and/or memory space;
  *     - 20x cards have control registers in standard PCI configuration space.
  *
  * Note: all 10x cards have PCI device ids 0x10..
  *       all 20x cards have PCI device ids 0x20..
  *
  * There are also Quartet Serial cards which use Oxford Semiconductor
  * 16954 quad UART PCI chip clocked by 18.432 MHz quartz.
  *
  * Note: some SIIG cards are probed by the parport_serial object.
  */
 #define PCI_DEVICE_ID_SIIG_1S_10x (PCI_DEVICE_ID_SIIG_1S_10x_550 & 0xfffc)
 #define PCI_DEVICE_ID_SIIG_2S_10x (PCI_DEVICE_ID_SIIG_2S_10x_550 & 0xfff8)
 static int pci_siig10x_init(struct pci_dev *dev)
 {
 	u16 data;
 	void __iomem *p;
 	switch (dev->device & 0xfff8) {
 	case PCI_DEVICE_ID_SIIG_1S_10x:	/* 1S */
 		data = 0xffdf;
 		break;
 	case PCI_DEVICE_ID_SIIG_2S_10x:	/* 2S, 2S1P */
 		data = 0xf7ff;
 		break;
 	default:			/* 1S1P, 4S */
 		data = 0xfffb;
 		break;
 	}
 	p = ioremap_nocache(pci_resource_start(dev, 0), 0x80);
 	if (p == NULL)
 		return -ENOMEM;
 	writew(readw(p + 0x28) & data, p + 0x28);
 	readw(p + 0x28);
 	iounmap(p);
 	return 0;
 }
 #define PCI_DEVICE_ID_SIIG_2S_20x (PCI_DEVICE_ID_SIIG_2S_20x_550 & 0xfffc)
 #define PCI_DEVICE_ID_SIIG_2S1P_20x (PCI_DEVICE_ID_SIIG_2S1P_20x_550 & 0xfffc)
 static int pci_siig20x_init(struct pci_dev *dev)
 {
 	u8 data;
 	/* Change clock frequency for the first UART. */
 	pci_read_config_byte(dev, 0x6f, &data);
 	pci_write_config_byte(dev, 0x6f, data & 0xef);
 	/* If this card has 2 UART, we have to do the same with second UART. */
 	if (((dev->device & 0xfffc) == PCI_DEVICE_ID_SIIG_2S_20x) ||
 	    ((dev->device & 0xfffc) == PCI_DEVICE_ID_SIIG_2S1P_20x)) {
 		pci_read_config_byte(dev, 0x73, &data);
 		pci_write_config_byte(dev, 0x73, data & 0xef);
 	}
 	return 0;
 }
 static int pci_siig_init(struct pci_dev *dev)
 {
 	unsigned int type = dev->device & 0xff00;
 	if (type == 0x1000)
 		return pci_siig10x_init(dev);
 	else if (type == 0x2000)
 		return pci_siig20x_init(dev);
 	moan_device("Unknown SIIG card", dev);
 	return -ENODEV;
 }
 static int pci_siig_setup(struct serial_private *priv,
 			  const struct pciserial_board *board,
 			  struct uart_8250_port *port, int idx)
 {
 	unsigned int bar = FL_GET_BASE(board->flags) + idx, offset = 0;
 	if (idx > 3) {
 		bar = 4;
 		offset = (idx - 4) * 8;
 	}
 	return setup_port(priv, port, bar, offset, 0);
 }
 /*
  * Timedia has an explosion of boards, and to avoid the PCI table from
  * growing *huge*, we use this function to collapse some 70 entries
  * in the PCI table into one, for sanity's and compactness's sake.
  */
 static const unsigned short timedia_single_port[] = {
 	0x4025, 0x4027, 0x4028, 0x5025, 0x5027, 0
 };
 static const unsigned short timedia_dual_port[] = {
 	0x0002, 0x4036, 0x4037, 0x4038, 0x4078, 0x4079, 0x4085,
 	0x4088, 0x4089, 0x5037, 0x5078, 0x5079, 0x5085, 0x6079,
 	0x7079, 0x8079, 0x8137, 0x8138, 0x8237, 0x8238, 0x9079,
 	0x9137, 0x9138, 0x9237, 0x9238, 0xA079, 0xB079, 0xC079,
 	0xD079, 0
 };
 static const unsigned short timedia_quad_port[] = {
 	0x4055, 0x4056, 0x4095, 0x4096, 0x5056, 0x8156, 0x8157,
 	0x8256, 0x8257, 0x9056, 0x9156, 0x9157, 0x9158, 0x9159,
 	0x9256, 0x9257, 0xA056, 0xA157, 0xA158, 0xA159, 0xB056,
 	0xB157, 0
 };
 static const unsigned short timedia_eight_port[] = {
 	0x4065, 0x4066, 0x5065, 0x5066, 0x8166, 0x9066, 0x9166,
 	0x9167, 0x9168, 0xA066, 0xA167, 0xA168, 0
 };
 static const struct timedia_struct {
 	int num;
 	const unsigned short *ids;
 } timedia_data[] = {
 	{ 1, timedia_single_port },
 	{ 2, timedia_dual_port },
 	{ 4, timedia_quad_port },
 	{ 8, timedia_eight_port }
 };
 /*
  * There are nearly 70 different Timedia/SUNIX PCI serial devices.  Instead of
  * listing them individually, this driver merely grabs them all with
  * PCI_ANY_ID.  Some of these devices, however, also feature a parallel port,
  * and should be left free to be claimed by parport_serial instead.
  */
 static int pci_timedia_probe(struct pci_dev *dev)
 {
 	/*
 	 * Check the third digit of the subdevice ID
 	 * (0,2,3,5,6: serial only -- 7,8,9: serial + parallel)
 	 */
 	if ((dev->subsystem_device & 0x00f0) >= 0x70) {
 		dev_info(&dev->dev,
 			"ignoring Timedia subdevice %04x for parport_serial\n",
 			dev->subsystem_device);
 		return -ENODEV;
 	}
 	return 0;
 }
 static int pci_timedia_init(struct pci_dev *dev)
 {
 	const unsigned short *ids;
 	int i, j;
 	for (i = 0; i < ARRAY_SIZE(timedia_data); i++) {
 		ids = timedia_data[i].ids;
 		for (j = 0; ids[j]; j++)
 			if (dev->subsystem_device == ids[j])
 				return timedia_data[i].num;
 	}
 	return 0;
 }
 /*
  * Timedia/SUNIX uses a mixture of BARs and offsets
  * Ugh, this is ugly as all hell --- TYT
  */
 static int
 pci_timedia_setup(struct serial_private *priv,
 		  const struct pciserial_board *board,
 		  struct uart_8250_port *port, int idx)
 {
 	unsigned int bar = 0, offset = board->first_offset;
 	switch (idx) {
 	case 0:
 		bar = 0;
 		break;
 	case 1:
 		offset = board->uart_offset;
 		bar = 0;
 		break;
 	case 2:
 		bar = 1;
 		break;
 	case 3:
 		offset = board->uart_offset;
 		/* FALLTHROUGH */
 	case 4: /* BAR 2 */
 	case 5: /* BAR 3 */
 	case 6: /* BAR 4 */
 	case 7: /* BAR 5 */
 		bar = idx - 2;
 	}
 	return setup_port(priv, port, bar, offset, board->reg_shift);
 }
 /*
  * Some Titan cards are also a little weird
  */
 static int
 titan_400l_800l_setup(struct serial_private *priv,
 		      const struct pciserial_board *board,
 		      struct uart_8250_port *port, int idx)
 {
 	unsigned int bar, offset = board->first_offset;
 	switch (idx) {
 	case 0:
 		bar = 1;
 		break;
 	case 1:
 		bar = 2;
 		break;
 	default:
 		bar = 4;
 		offset = (idx - 2) * board->uart_offset;
 	}
 	return setup_port(priv, port, bar, offset, board->reg_shift);
 }
 static int pci_xircom_init(struct pci_dev *dev)
 {
 	msleep(100);
 	return 0;
 }
 static int pci_ni8420_init(struct pci_dev *dev)
 {
 	void __iomem *p;
 	unsigned int bar = 0;
 	if ((pci_resource_flags(dev, bar) & IORESOURCE_MEM) == 0) {
 		moan_device("no memory in bar", dev);
 		return 0;
 	}
 	p = pci_ioremap_bar(dev, bar);
 	if (p == NULL)
 		return -ENOMEM;
 	/* Enable CPU Interrupt */
 	writel(readl(p + NI8420_INT_ENABLE_REG) | NI8420_INT_ENABLE_BIT,
 	       p + NI8420_INT_ENABLE_REG);
 	iounmap(p);
 	return 0;
 }
 #define MITE_IOWBSR1_WSIZE	0xa
 #define MITE_IOWBSR1_WIN_OFFSET	0x800
 #define MITE_IOWBSR1_WENAB	(1 << 7)
 #define MITE_LCIMR1_IO_IE_0	(1 << 24)
 #define MITE_LCIMR2_SET_CPU_IE	(1 << 31)
 #define MITE_IOWCR1_RAMSEL_MASK	0xfffffffe
 static int pci_ni8430_init(struct pci_dev *dev)
 {
 	void __iomem *p;
 	struct pci_bus_region region;
 	u32 device_window;
 	unsigned int bar = 0;
 	if ((pci_resource_flags(dev, bar) & IORESOURCE_MEM) == 0) {
 		moan_device("no memory in bar", dev);
 		return 0;
 	}
 	p = pci_ioremap_bar(dev, bar);
 	if (p == NULL)
 		return -ENOMEM;
 	/*
 	 * Set device window address and size in BAR0, while acknowledging that
 	 * the resource structure may contain a translated address that differs
 	 * from the address the device responds to.
 	 */
 	pcibios_resource_to_bus(dev->bus, &region, &dev->resource[bar]);
 	device_window = ((region.start + MITE_IOWBSR1_WIN_OFFSET) & 0xffffff00)
 	                | MITE_IOWBSR1_WENAB | MITE_IOWBSR1_WSIZE;
 	writel(device_window, p + MITE_IOWBSR1);
 	/* Set window access to go to RAMSEL IO address space */
 	writel((readl(p + MITE_IOWCR1) & MITE_IOWCR1_RAMSEL_MASK),
 	       p + MITE_IOWCR1);
 	/* Enable IO Bus Interrupt 0 */
 	writel(MITE_LCIMR1_IO_IE_0, p + MITE_LCIMR1);
 	/* Enable CPU Interrupt */
 	writel(MITE_LCIMR2_SET_CPU_IE, p + MITE_LCIMR2);
 	iounmap(p);
 	return 0;
 }
 /* UART Port Control Register */
 #define NI8430_PORTCON	0x0f
 #define NI8430_PORTCON_TXVR_ENABLE	(1 << 3)
 static int
 pci_ni8430_setup(struct serial_private *priv,
 		 const struct pciserial_board *board,
 		 struct uart_8250_port *port, int idx)
 {
 	struct pci_dev *dev = priv->dev;
 	void __iomem *p;
 	unsigned int bar, offset = board->first_offset;
 	if (idx >= board->num_ports)
 		return 1;
 	bar = FL_GET_BASE(board->flags);
 	offset += idx * board->uart_offset;
 	p = pci_ioremap_bar(dev, bar);
 	if (!p)
 		return -ENOMEM;
 	/* enable the transceiver */
 	writeb(readb(p + offset + NI8430_PORTCON) | NI8430_PORTCON_TXVR_ENABLE,
 	       p + offset + NI8430_PORTCON);
 	iounmap(p);
 	return setup_port(priv, port, bar, offset, board->reg_shift);
 }
 static int pci_netmos_9900_setup(struct serial_private *priv,
 				const struct pciserial_board *board,
 				struct uart_8250_port *port, int idx)
 {
 	unsigned int bar;
 	if ((priv->dev->device != PCI_DEVICE_ID_NETMOS_9865) &&
 	    (priv->dev->subsystem_device & 0xff00) == 0x3000) {
 		/* netmos apparently orders BARs by datasheet layout, so serial
 		 * ports get BARs 0 and 3 (or 1 and 4 for memmapped)
 		 */
 		bar = 3 * idx;
 		return setup_port(priv, port, bar, 0, board->reg_shift);
 	} else {
 		return pci_default_setup(priv, board, port, idx);
 	}
 }
 /* the 99xx series comes with a range of device IDs and a variety
  * of capabilities:
  *
  * 9900 has varying capabilities and can cascade to sub-controllers
  *   (cascading should be purely internal)
  * 9904 is hardwired with 4 serial ports
  * 9912 and 9922 are hardwired with 2 serial ports
  */
 static int pci_netmos_9900_numports(struct pci_dev *dev)
 {
 	unsigned int c = dev->class;
 	unsigned int pi;
 	unsigned short sub_serports;
 	pi = (c & 0xff);
 	if (pi == 2) {
 		return 1;
 	} else if ((pi == 0) &&
 			   (dev->device == PCI_DEVICE_ID_NETMOS_9900)) {
 		/* two possibilities: 0x30ps encodes number of parallel and
 		 * serial ports, or 0x1000 indicates *something*. This is not
 		 * immediately obvious, since the 2s1p+4s configuration seems
 		 * to offer all functionality on functions 0..2, while still
 		 * advertising the same function 3 as the 4s+2s1p config.
 		 */
 		sub_serports = dev->subsystem_device & 0xf;
 		if (sub_serports > 0) {
 			return sub_serports;
 		} else {
 			dev_err(&dev->dev, "NetMos/Mostech serial driver ignoring port on ambiguous config.\n");
 			return 0;
 		}
 	}
 	moan_device("unknown NetMos/Mostech program interface", dev);
 	return 0;
 }
 static int pci_netmos_init(struct pci_dev *dev)
 {
 	/* subdevice 0x00PS means <P> parallel, <S> serial */
 	unsigned int num_serial = dev->subsystem_device & 0xf;
 	if ((dev->device == PCI_DEVICE_ID_NETMOS_9901) ||
 		(dev->device == PCI_DEVICE_ID_NETMOS_9865))
 		return 0;
 	if (dev->subsystem_vendor == PCI_VENDOR_ID_IBM &&
 			dev->subsystem_device == 0x0299)
 		return 0;
 	switch (dev->device) { /* FALLTHROUGH on all */
 		case PCI_DEVICE_ID_NETMOS_9904:
 		case PCI_DEVICE_ID_NETMOS_9912:
 		case PCI_DEVICE_ID_NETMOS_9922:
 		case PCI_DEVICE_ID_NETMOS_9900:
 			num_serial = pci_netmos_9900_numports(dev);
 			break;
 		default:
 			if (num_serial == 0 ) {
 				moan_device("unknown NetMos/Mostech device", dev);
 			}
 	}
 	if (num_serial == 0)
 		return -ENODEV;
 	return num_serial;
 }
 /*
  * These chips are available with optionally one parallel port and up to
  * two serial ports. Unfortunately they all have the same product id.
  *
  * Basic configuration is done over a region of 32 I/O ports. The base
  * ioport is called INTA or INTC, depending on docs/other drivers.
  *
  * The region of the 32 I/O ports is configured in POSIO0R...
  */
 /* registers */
 #define ITE_887x_MISCR		0x9c
 #define ITE_887x_INTCBAR	0x78
 #define ITE_887x_UARTBAR	0x7c
 #define ITE_887x_PS0BAR		0x10
 #define ITE_887x_POSIO0		0x60
 /* I/O space size */
 #define ITE_887x_IOSIZE		32
 /* I/O space size (bits 26-24; 8 bytes = 011b) */
 #define ITE_887x_POSIO_IOSIZE_8		(3 << 24)
 /* I/O space size (bits 26-24; 32 bytes = 101b) */
 #define ITE_887x_POSIO_IOSIZE_32	(5 << 24)
 /* Decoding speed (1 = slow, 2 = medium, 3 = fast) */
 #define ITE_887x_POSIO_SPEED		(3 << 29)
 /* enable IO_Space bit */
 #define ITE_887x_POSIO_ENABLE		(1 << 31)
 static int pci_ite887x_init(struct pci_dev *dev)
 {
 	/* inta_addr are the configuration addresses of the ITE */
 	static const short inta_addr[] = { 0x2a0, 0x2c0, 0x220, 0x240, 0x1e0,
 							0x200, 0x280, 0 };
 	int ret, i, type;
 	struct resource *iobase = NULL;
 	u32 miscr, uartbar, ioport;
 	/* search for the base-ioport */
 	i = 0;
 	while (inta_addr[i] && iobase == NULL) {
 		iobase = request_region(inta_addr[i], ITE_887x_IOSIZE,
 								"ite887x");
 		if (iobase != NULL) {
 			/* write POSIO0R - speed | size | ioport */
 			pci_write_config_dword(dev, ITE_887x_POSIO0,
 				ITE_887x_POSIO_ENABLE | ITE_887x_POSIO_SPEED |
 				ITE_887x_POSIO_IOSIZE_32 | inta_addr[i]);
 			/* write INTCBAR - ioport */
 			pci_write_config_dword(dev, ITE_887x_INTCBAR,
 								inta_addr[i]);
 			ret = inb(inta_addr[i]);
 			if (ret != 0xff) {
 				/* ioport connected */
 				break;
 			}
 			release_region(iobase->start, ITE_887x_IOSIZE);
 			iobase = NULL;
 		}
 		i++;
 	}
 	if (!inta_addr[i]) {
 		dev_err(&dev->dev, "ite887x: could not find iobase\n");
 		return -ENODEV;
 	}
 	/* start of undocumented type checking (see parport_pc.c) */
 	type = inb(iobase->start + 0x18) & 0x0f;
 	switch (type) {
 	case 0x2:	/* ITE8871 (1P) */
 	case 0xa:	/* ITE8875 (1P) */
 		ret = 0;
 		break;
 	case 0xe:	/* ITE8872 (2S1P) */
 		ret = 2;
 		break;
 	case 0x6:	/* ITE8873 (1S) */
 		ret = 1;
 		break;
 	case 0x8:	/* ITE8874 (2S) */
 		ret = 2;
 		break;
 	default:
 		moan_device("Unknown ITE887x", dev);
 		ret = -ENODEV;
 	}
 	/* configure all serial ports */
 	for (i = 0; i < ret; i++) {
 		/* read the I/O port from the device */
 		pci_read_config_dword(dev, ITE_887x_PS0BAR + (0x4 * (i + 1)),
 								&ioport);
 		ioport &= 0x0000FF00;	/* the actual base address */
 		pci_write_config_dword(dev, ITE_887x_POSIO0 + (0x4 * (i + 1)),
 			ITE_887x_POSIO_ENABLE | ITE_887x_POSIO_SPEED |
 			ITE_887x_POSIO_IOSIZE_8 | ioport);
 		/* write the ioport to the UARTBAR */
 		pci_read_config_dword(dev, ITE_887x_UARTBAR, &uartbar);
 		uartbar &= ~(0xffff << (16 * i));	/* clear half the reg */
 		uartbar |= (ioport << (16 * i));	/* set the ioport */
 		pci_write_config_dword(dev, ITE_887x_UARTBAR, uartbar);
 		/* get current config */
 		pci_read_config_dword(dev, ITE_887x_MISCR, &miscr);
 		/* disable interrupts (UARTx_Routing[3:0]) */
 		miscr &= ~(0xf << (12 - 4 * i));
 		/* activate the UART (UARTx_En) */
 		miscr |= 1 << (23 - i);
 		/* write new config with activated UART */
 		pci_write_config_dword(dev, ITE_887x_MISCR, miscr);
 	}
 	if (ret <= 0) {
 		/* the device has no UARTs if we get here */
 		release_region(iobase->start, ITE_887x_IOSIZE);
 	}
 	return ret;
 }
 static void pci_ite887x_exit(struct pci_dev *dev)
 {
 	u32 ioport;
 	/* the ioport is bit 0-15 in POSIO0R */
 	pci_read_config_dword(dev, ITE_887x_POSIO0, &ioport);
 	ioport &= 0xffff;
 	release_region(ioport, ITE_887x_IOSIZE);
 }
 /*
  * EndRun Technologies.
  * Determine the number of ports available on the device.
  */
 #define PCI_VENDOR_ID_ENDRUN			0x7401
 #define PCI_DEVICE_ID_ENDRUN_1588	0xe100
 static int pci_endrun_init(struct pci_dev *dev)
 {
 	u8 __iomem *p;
 	unsigned long deviceID;
 	unsigned int  number_uarts = 0;
 	/* EndRun device is all 0xexxx */
 	if (dev->vendor == PCI_VENDOR_ID_ENDRUN &&
 		(dev->device & 0xf000) != 0xe000)
 		return 0;
 	p = pci_iomap(dev, 0, 5);
 	if (p == NULL)
 		return -ENOMEM;
 	deviceID = ioread32(p);
 	/* EndRun device */
 	if (deviceID == 0x07000200) {
 		number_uarts = ioread8(p + 4);
 		dev_dbg(&dev->dev,
 			"%d ports detected on EndRun PCI Express device\n",
 			number_uarts);
 	}
 	pci_iounmap(dev, p);
 	return number_uarts;
 }
 /*
  * Oxford Semiconductor Inc.
  * Check that device is part of the Tornado range of devices, then determine
  * the number of ports available on the device.
  */
 static int pci_oxsemi_tornado_init(struct pci_dev *dev)
 {
 	u8 __iomem *p;
 	unsigned long deviceID;
 	unsigned int  number_uarts = 0;
 	/* OxSemi Tornado devices are all 0xCxxx */
 	if (dev->vendor == PCI_VENDOR_ID_OXSEMI &&
 	    (dev->device & 0xF000) != 0xC000)
 		return 0;
 	p = pci_iomap(dev, 0, 5);
 	if (p == NULL)
 		return -ENOMEM;
 	deviceID = ioread32(p);
 	/* Tornado device */
 	if (deviceID == 0x07000200) {
 		number_uarts = ioread8(p + 4);
 		dev_dbg(&dev->dev,
 			"%d ports detected on Oxford PCI Express device\n",
 			number_uarts);
 	}
 	pci_iounmap(dev, p);
 	return number_uarts;
 }
 static int pci_asix_setup(struct serial_private *priv,
 		  const struct pciserial_board *board,
 		  struct uart_8250_port *port, int idx)
 {
 	port->bugs |= UART_BUG_PARITY;
 	return pci_default_setup(priv, board, port, idx);
 }
 /* Quatech devices have their own extra interface features */
 struct quatech_feature {
 	u16 devid;
 	bool amcc;
 };
 #define QPCR_TEST_FOR1		0x3F
 #define QPCR_TEST_GET1		0x00
 #define QPCR_TEST_FOR2		0x40
 #define QPCR_TEST_GET2		0x40
 #define QPCR_TEST_FOR3		0x80
 #define QPCR_TEST_GET3		0x40
 #define QPCR_TEST_FOR4		0xC0
 #define QPCR_TEST_GET4		0x80
 #define QOPR_CLOCK_X1		0x0000
 #define QOPR_CLOCK_X2		0x0001
 #define QOPR_CLOCK_X4		0x0002
 #define QOPR_CLOCK_X8		0x0003
 #define QOPR_CLOCK_RATE_MASK	0x0003
 static struct quatech_feature quatech_cards[] = {
 	{ PCI_DEVICE_ID_QUATECH_QSC100,   1 },
 	{ PCI_DEVICE_ID_QUATECH_DSC100,   1 },
 	{ PCI_DEVICE_ID_QUATECH_DSC100E,  0 },
 	{ PCI_DEVICE_ID_QUATECH_DSC200,   1 },
 	{ PCI_DEVICE_ID_QUATECH_DSC200E,  0 },
 	{ PCI_DEVICE_ID_QUATECH_ESC100D,  1 },
 	{ PCI_DEVICE_ID_QUATECH_ESC100M,  1 },
 	{ PCI_DEVICE_ID_QUATECH_QSCP100,  1 },
 	{ PCI_DEVICE_ID_QUATECH_DSCP100,  1 },
 	{ PCI_DEVICE_ID_QUATECH_QSCP200,  1 },
 	{ PCI_DEVICE_ID_QUATECH_DSCP200,  1 },
 	{ PCI_DEVICE_ID_QUATECH_ESCLP100, 0 },
 	{ PCI_DEVICE_ID_QUATECH_QSCLP100, 0 },
 	{ PCI_DEVICE_ID_QUATECH_DSCLP100, 0 },
 	{ PCI_DEVICE_ID_QUATECH_SSCLP100, 0 },
 	{ PCI_DEVICE_ID_QUATECH_QSCLP200, 0 },
 	{ PCI_DEVICE_ID_QUATECH_DSCLP200, 0 },
 	{ PCI_DEVICE_ID_QUATECH_SSCLP200, 0 },
 	{ PCI_DEVICE_ID_QUATECH_SPPXP_100, 0 },
 	{ 0, }
 };
 static int pci_quatech_amcc(u16 devid)
 {
 	struct quatech_feature *qf = &quatech_cards[0];
 	while (qf->devid) {
 		if (qf->devid == devid)
 			return qf->amcc;
 		qf++;
 	}
 	pr_err("quatech: unknown port type '0x%04X'.\n", devid);
 	return 0;
 };
 static int pci_quatech_rqopr(struct uart_8250_port *port)
 {
 	unsigned long base = port->port.iobase;
 	u8 LCR, val;
 	LCR = inb(base + UART_LCR);
 	outb(0xBF, base + UART_LCR);
 	val = inb(base + UART_SCR);
 	outb(LCR, base + UART_LCR);
 	return val;
 }
 static void pci_quatech_wqopr(struct uart_8250_port *port, u8 qopr)
 {
 	unsigned long base = port->port.iobase;
 	u8 LCR, val;
 	LCR = inb(base + UART_LCR);
 	outb(0xBF, base + UART_LCR);
 	val = inb(base + UART_SCR);
 	outb(qopr, base + UART_SCR);
 	outb(LCR, base + UART_LCR);
 }
 static int pci_quatech_rqmcr(struct uart_8250_port *port)
 {
 	unsigned long base = port->port.iobase;
 	u8 LCR, val, qmcr;
 	LCR = inb(base + UART_LCR);
 	outb(0xBF, base + UART_LCR);
 	val = inb(base + UART_SCR);
 	outb(val | 0x10, base + UART_SCR);
 	qmcr = inb(base + UART_MCR);
 	outb(val, base + UART_SCR);
 	outb(LCR, base + UART_LCR);
 	return qmcr;
 }
 static void pci_quatech_wqmcr(struct uart_8250_port *port, u8 qmcr)
 {
 	unsigned long base = port->port.iobase;
 	u8 LCR, val;
 	LCR = inb(base + UART_LCR);
 	outb(0xBF, base + UART_LCR);
 	val = inb(base + UART_SCR);
 	outb(val | 0x10, base + UART_SCR);
 	outb(qmcr, base + UART_MCR);
 	outb(val, base + UART_SCR);
 	outb(LCR, base + UART_LCR);
 }
 static int pci_quatech_has_qmcr(struct uart_8250_port *port)
 {
 	unsigned long base = port->port.iobase;
 	u8 LCR, val;
 	LCR = inb(base + UART_LCR);
 	outb(0xBF, base + UART_LCR);
 	val = inb(base + UART_SCR);
 	if (val & 0x20) {
 		outb(0x80, UART_LCR);
 		if (!(inb(UART_SCR) & 0x20)) {
 			outb(LCR, base + UART_LCR);
 			return 1;
 		}
 	}
 	return 0;
 }
 static int pci_quatech_test(struct uart_8250_port *port)
 {
 	u8 reg;
 	u8 qopr = pci_quatech_rqopr(port);
 	pci_quatech_wqopr(port, qopr & QPCR_TEST_FOR1);
 	reg = pci_quatech_rqopr(port) & 0xC0;
 	if (reg != QPCR_TEST_GET1)
 		return -EINVAL;
 	pci_quatech_wqopr(port, (qopr & QPCR_TEST_FOR1)|QPCR_TEST_FOR2);
 	reg = pci_quatech_rqopr(port) & 0xC0;
 	if (reg != QPCR_TEST_GET2)
 		return -EINVAL;
 	pci_quatech_wqopr(port, (qopr & QPCR_TEST_FOR1)|QPCR_TEST_FOR3);
 	reg = pci_quatech_rqopr(port) & 0xC0;
 	if (reg != QPCR_TEST_GET3)
 		return -EINVAL;
 	pci_quatech_wqopr(port, (qopr & QPCR_TEST_FOR1)|QPCR_TEST_FOR4);
 	reg = pci_quatech_rqopr(port) & 0xC0;
 	if (reg != QPCR_TEST_GET4)
 		return -EINVAL;
 	pci_quatech_wqopr(port, qopr);
 	return 0;
 }
 static int pci_quatech_clock(struct uart_8250_port *port)
 {
 	u8 qopr, reg, set;
 	unsigned long clock;
 	if (pci_quatech_test(port) < 0)
 		return 1843200;
 	qopr = pci_quatech_rqopr(port);
 	pci_quatech_wqopr(port, qopr & ~QOPR_CLOCK_X8);
 	reg = pci_quatech_rqopr(port);
 	if (reg & QOPR_CLOCK_X8) {
 		clock = 1843200;
 		goto out;
 	}
 	pci_quatech_wqopr(port, qopr | QOPR_CLOCK_X8);
 	reg = pci_quatech_rqopr(port);
 	if (!(reg & QOPR_CLOCK_X8)) {
 		clock = 1843200;
 		goto out;
 	}
 	reg &= QOPR_CLOCK_X8;
 	if (reg == QOPR_CLOCK_X2) {
 		clock =  3685400;
 		set = QOPR_CLOCK_X2;
 	} else if (reg == QOPR_CLOCK_X4) {
 		clock = 7372800;
 		set = QOPR_CLOCK_X4;
 	} else if (reg == QOPR_CLOCK_X8) {
 		clock = 14745600;
 		set = QOPR_CLOCK_X8;
 	} else {
 		clock = 1843200;
 		set = QOPR_CLOCK_X1;
 	}
 	qopr &= ~QOPR_CLOCK_RATE_MASK;
 	qopr |= set;
 out:
 	pci_quatech_wqopr(port, qopr);
 	return clock;
 }
 static int pci_quatech_rs422(struct uart_8250_port *port)
 {
 	u8 qmcr;
 	int rs422 = 0;
 	if (!pci_quatech_has_qmcr(port))
 		return 0;
 	qmcr = pci_quatech_rqmcr(port);
 	pci_quatech_wqmcr(port, 0xFF);
 	if (pci_quatech_rqmcr(port))
 		rs422 = 1;
 	pci_quatech_wqmcr(port, qmcr);
 	return rs422;
 }
 static int pci_quatech_init(struct pci_dev *dev)
 {
 	if (pci_quatech_amcc(dev->device)) {
 		unsigned long base = pci_resource_start(dev, 0);
 		if (base) {
 			u32 tmp;
 			outl(inl(base + 0x38) | 0x00002000, base + 0x38);
 			tmp = inl(base + 0x3c);
 			outl(tmp | 0x01000000, base + 0x3c);
 			outl(tmp &= ~0x01000000, base + 0x3c);
 		}
 	}
 	return 0;
 }
 static int pci_quatech_setup(struct serial_private *priv,
 		  const struct pciserial_board *board,
 		  struct uart_8250_port *port, int idx)
 {
 	/* Needed by pci_quatech calls below */
 	port->port.iobase = pci_resource_start(priv->dev, FL_GET_BASE(board->flags));
 	/* Set up the clocking */
 	port->port.uartclk = pci_quatech_clock(port);
 	/* For now just warn about RS422 */
 	if (pci_quatech_rs422(port))
 		pr_warn("quatech: software control of RS422 features not currently supported.\n");
 	return pci_default_setup(priv, board, port, idx);
 }
 static void pci_quatech_exit(struct pci_dev *dev)
 {
 }
 static int pci_default_setup(struct serial_private *priv,
 		  const struct pciserial_board *board,
 		  struct uart_8250_port *port, int idx)
 {
 	unsigned int bar, offset = board->first_offset, maxnr;
 	bar = FL_GET_BASE(board->flags);
 	if (board->flags & FL_BASE_BARS)
 		bar += idx;
 	else
 		offset += idx * board->uart_offset;
 	maxnr = (pci_resource_len(priv->dev, bar) - board->first_offset) >>
 		(board->reg_shift + 3);
 	if (board->flags & FL_REGION_SZ_CAP && idx >= maxnr)
 		return 1;
 	return setup_port(priv, port, bar, offset, board->reg_shift);
 }
 static int pci_pericom_setup(struct serial_private *priv,
 		  const struct pciserial_board *board,
 		  struct uart_8250_port *port, int idx)
 {
 	unsigned int bar, offset = board->first_offset, maxnr;
 	bar = FL_GET_BASE(board->flags);
 	if (board->flags & FL_BASE_BARS)
 		bar += idx;
 	else
 		offset += idx * board->uart_offset;
 	maxnr = (pci_resource_len(priv->dev, bar) - board->first_offset) >>
 		(board->reg_shift + 3);
 	if (board->flags & FL_REGION_SZ_CAP && idx >= maxnr)
 		return 1;
 	port->port.uartclk = 14745600;
 	return setup_port(priv, port, bar, offset, board->reg_shift);
 }
 static int
 ce4100_serial_setup(struct serial_private *priv,
 		  const struct pciserial_board *board,
 		  struct uart_8250_port *port, int idx)
 {
 	int ret;
 	ret = setup_port(priv, port, idx, 0, board->reg_shift);
 	port->port.iotype = UPIO_MEM32;
 	port->port.type = PORT_XSCALE;
 	port->port.flags = (port->port.flags | UPF_FIXED_PORT | UPF_FIXED_TYPE);
 	port->port.regshift = 2;
 	return ret;
 }
 #define PCI_DEVICE_ID_INTEL_BYT_UART1	0x0f0a
 #define PCI_DEVICE_ID_INTEL_BYT_UART2	0x0f0c
 #define PCI_DEVICE_ID_INTEL_BSW_UART1	0x228a
 #define PCI_DEVICE_ID_INTEL_BSW_UART2	0x228c
 #define BYT_PRV_CLK			0x800
 #define BYT_PRV_CLK_EN			(1 << 0)
 #define BYT_PRV_CLK_M_VAL_SHIFT		1
 #define BYT_PRV_CLK_N_VAL_SHIFT		16
 #define BYT_PRV_CLK_UPDATE		(1 << 31)
 #define BYT_TX_OVF_INT			0x820
 #define BYT_TX_OVF_INT_MASK		(1 << 1)
 static void
 byt_set_termios(struct uart_port *p, struct ktermios *termios,
 		struct ktermios *old)
 {
 	unsigned int baud = tty_termios_baud_rate(termios);
 	unsigned int m, n;
 	u32 reg;
 	/*
 	 * For baud rates 0.5M, 1M, 1.5M, 2M, 2.5M, 3M, 3.5M and 4M the
 	 * dividers must be adjusted.
 	 *
 	 * uartclk = (m / n) * 100 MHz, where m <= n
 	 */
 	switch (baud) {
 	case 500000:
 	case 1000000:
 	case 2000000:
 	case 4000000:
 		m = 64;
 		n = 100;
 		p->uartclk = 64000000;
 		break;
 	case 3500000:
 		m = 56;
 		n = 100;
 		p->uartclk = 56000000;
 		break;
 	case 1500000:
 	case 3000000:
 		m = 48;
 		n = 100;
 		p->uartclk = 48000000;
 		break;
 	case 2500000:
 		m = 40;
 		n = 100;
 		p->uartclk = 40000000;
 		break;
 	default:
 		m = 2304;
 		n = 3125;
 		p->uartclk = 73728000;
 	}
 	/* Reset the clock */
 	reg = (m << BYT_PRV_CLK_M_VAL_SHIFT) | (n << BYT_PRV_CLK_N_VAL_SHIFT);
 	writel(reg, p->membase + BYT_PRV_CLK);
 	reg |= BYT_PRV_CLK_EN | BYT_PRV_CLK_UPDATE;
 	writel(reg, p->membase + BYT_PRV_CLK);
 	serial8250_do_set_termios(p, termios, old);
 }
 static bool byt_dma_filter(struct dma_chan *chan, void *param)
 {
 	struct dw_dma_slave *dws = param;
 	if (dws->dma_dev != chan->device->dev)
 		return false;
 	chan->private = dws;
 	return true;
 }
 static int
 byt_serial_setup(struct serial_private *priv,
 		 const struct pciserial_board *board,
 		 struct uart_8250_port *port, int idx)
 {
 	struct pci_dev *pdev = priv->dev;
 	struct device *dev = port->port.dev;
 	struct uart_8250_dma *dma;
 	struct dw_dma_slave *tx_param, *rx_param;
 	struct pci_dev *dma_dev;
 	int ret;
 	dma = devm_kzalloc(dev, sizeof(*dma), GFP_KERNEL);
 	if (!dma)
 		return -ENOMEM;
 	tx_param = devm_kzalloc(dev, sizeof(*tx_param), GFP_KERNEL);
 	if (!tx_param)
 		return -ENOMEM;
 	rx_param = devm_kzalloc(dev, sizeof(*rx_param), GFP_KERNEL);
 	if (!rx_param)
 		return -ENOMEM;
 	switch (pdev->device) {
 	case PCI_DEVICE_ID_INTEL_BYT_UART1:
 	case PCI_DEVICE_ID_INTEL_BSW_UART1:
 		rx_param->src_id = 3;
 		tx_param->dst_id = 2;
 		break;
 	case PCI_DEVICE_ID_INTEL_BYT_UART2:
 	case PCI_DEVICE_ID_INTEL_BSW_UART2:
 		rx_param->src_id = 5;
 		tx_param->dst_id = 4;
 		break;
 	default:
 		return -EINVAL;
 	}
 	rx_param->src_master = 1;
 	rx_param->dst_master = 0;
 	dma->rxconf.src_maxburst = 16;
 	tx_param->src_master = 1;
 	tx_param->dst_master = 0;
 	dma->txconf.dst_maxburst = 16;
 	dma_dev = pci_get_slot(pdev->bus, PCI_DEVFN(PCI_SLOT(pdev->devfn), 0));
 	rx_param->dma_dev = &dma_dev->dev;
 	tx_param->dma_dev = &dma_dev->dev;
 	dma->fn = byt_dma_filter;
 	dma->rx_param = rx_param;
 	dma->tx_param = tx_param;
 	ret = pci_default_setup(priv, board, port, idx);
 	port->port.iotype = UPIO_MEM;
 	port->port.type = PORT_16550A;
 	port->port.flags = (port->port.flags | UPF_FIXED_PORT | UPF_FIXED_TYPE);
 	port->port.set_termios = byt_set_termios;
 	port->port.fifosize = 64;
 	port->tx_loadsz = 64;
 	port->dma = dma;
 	port->capabilities = UART_CAP_FIFO | UART_CAP_AFE;
 	/* Disable Tx counter interrupts */
 	writel(BYT_TX_OVF_INT_MASK, port->port.membase + BYT_TX_OVF_INT);
 	return ret;
 }
 static int
 pci_omegapci_setup(struct serial_private *priv,
 		      const struct pciserial_board *board,
 		      struct uart_8250_port *port, int idx)
 {
 	return setup_port(priv, port, 2, idx * 8, 0);
 }
 static int
 pci_brcm_trumanage_setup(struct serial_private *priv,
 			 const struct pciserial_board *board,
 			 struct uart_8250_port *port, int idx)
 {
 	int ret = pci_default_setup(priv, board, port, idx);
 	port->port.type = PORT_BRCM_TRUMANAGE;
 	port->port.flags = (port->port.flags | UPF_FIXED_PORT | UPF_FIXED_TYPE);
 	return ret;
 }
 static int pci_fintek_setup(struct serial_private *priv,
 			    const struct pciserial_board *board,
 			    struct uart_8250_port *port, int idx)
 {
 	struct pci_dev *pdev = priv->dev;
 	unsigned long base;
 	unsigned long iobase;
 	unsigned long ciobase = 0;
 	u8 config_base;
 	u32 bar_data[3];
 	/*
 	 * Find each UARTs offset in PCI configuraion space
 	 */
 	switch (idx) {
 	case 0:
 		config_base = 0x40;
 		break;
 	case 1:
 		config_base = 0x48;
 		break;
 	case 2:
 		config_base = 0x50;
 		break;
 	case 3:
 		config_base = 0x58;
 		break;
 	case 4:
 		config_base = 0x60;
 		break;
 	case 5:
 		config_base = 0x68;
 		break;
 	case 6:
 		config_base = 0x70;
 		break;
 	case 7:
 		config_base = 0x78;
 		break;
 	case 8:
 		config_base = 0x80;
 		break;
 	case 9:
 		config_base = 0x88;
 		break;
 	case 10:
 		config_base = 0x90;
 		break;
 	case 11:
 		config_base = 0x98;
 		break;
 	default:
 		/* Unknown number of ports, get out of here */
 		return -EINVAL;
 	}
 	if (idx < 4) {
 		base = pci_resource_start(priv->dev, 3);
 		ciobase = (int)(base + (0x8 * idx));
 	}
 	/* Get the io address dispatch from the BIOS */
 	pci_read_config_dword(pdev, 0x24, &bar_data[0]);
 	pci_read_config_dword(pdev, 0x20, &bar_data[1]);
 	pci_read_config_dword(pdev, 0x1c, &bar_data[2]);
 	/* Calculate Real IO Port */
 	iobase = (bar_data[idx/4] & 0xffffffe0) + (idx % 4) * 8;
 	dev_dbg(&pdev->dev, "%s: idx=%d iobase=0x%lx ciobase=0x%lx config_base=0x%2x\n",
 		__func__, idx, iobase, ciobase, config_base);
 	/* Enable UART I/O port */
 	pci_write_config_byte(pdev, config_base + 0x00, 0x01);
 	/* Select 128-byte FIFO and 8x FIFO threshold */
 	pci_write_config_byte(pdev, config_base + 0x01, 0x33);
 	/* LSB UART */
 	pci_write_config_byte(pdev, config_base + 0x04, (u8)(iobase & 0xff));
 	/* MSB UART */
 	pci_write_config_byte(pdev, config_base + 0x05, (u8)((iobase & 0xff00) >> 8));
 	/* irq number, this usually fails, but the spec says to do it anyway. */
 	pci_write_config_byte(pdev, config_base + 0x06, pdev->irq);
 	port->port.iotype = UPIO_PORT;
 	port->port.iobase = iobase;
 	port->port.mapbase = 0;
 	port->port.membase = NULL;
 	port->port.regshift = 0;
 	return 0;
 }
 static int skip_tx_en_setup(struct serial_private *priv,
 			const struct pciserial_board *board,
 			struct uart_8250_port *port, int idx)
 {
 	port->port.flags |= UPF_NO_TXEN_TEST;
 	dev_dbg(&priv->dev->dev,
 		"serial8250: skipping TxEn test for device [%04x:%04x] subsystem [%04x:%04x]\n",
 		priv->dev->vendor, priv->dev->device,
 		priv->dev->subsystem_vendor, priv->dev->subsystem_device);
 	return pci_default_setup(priv, board, port, idx);
 }
 static void kt_handle_break(struct uart_port *p)
 {
 	struct uart_8250_port *up = up_to_u8250p(p);
 	/*
 	 * On receipt of a BI, serial device in Intel ME (Intel
 	 * management engine) needs to have its fifos cleared for sane
 	 * SOL (Serial Over Lan) output.
 	 */
 	serial8250_clear_and_reinit_fifos(up);
 }
 static unsigned int kt_serial_in(struct uart_port *p, int offset)
 {
 	struct uart_8250_port *up = up_to_u8250p(p);
 	unsigned int val;
 	/*
 	 * When the Intel ME (management engine) gets reset its serial
 	 * port registers could return 0 momentarily.  Functions like
 	 * serial8250_console_write, read and save the IER, perform
 	 * some operation and then restore it.  In order to avoid
 	 * setting IER register inadvertently to 0, if the value read
 	 * is 0, double check with ier value in uart_8250_port and use
 	 * that instead.  up->ier should be the same value as what is
 	 * currently configured.
 	 */
 	val = inb(p->iobase + offset);
 	if (offset == UART_IER) {
 		if (val == 0)
 			val = up->ier;
 	}
 	return val;
 }
 static int kt_serial_setup(struct serial_private *priv,
 			   const struct pciserial_board *board,
 			   struct uart_8250_port *port, int idx)
 {
 	port->port.flags |= UPF_BUG_THRE;
 	port->port.serial_in = kt_serial_in;
 	port->port.handle_break = kt_handle_break;
 	return skip_tx_en_setup(priv, board, port, idx);
 }
 static int pci_eg20t_init(struct pci_dev *dev)
 {
 #if defined(CONFIG_SERIAL_PCH_UART) || defined(CONFIG_SERIAL_PCH_UART_MODULE)
 	return -ENODEV;
 #else
 	return 0;
 #endif
 }
 static int
 pci_xr17c154_setup(struct serial_private *priv,
 		  const struct pciserial_board *board,
 		  struct uart_8250_port *port, int idx)
 {
 	port->port.flags |= UPF_EXAR_EFR;
 	return pci_default_setup(priv, board, port, idx);
 }
 static int
 pci_xr17v35x_setup(struct serial_private *priv,
 		  const struct pciserial_board *board,
 		  struct uart_8250_port *port, int idx)
 {
 	u8 __iomem *p;
 	p = pci_ioremap_bar(priv->dev, 0);
 	if (p == NULL)
 		return -ENOMEM;
 	port->port.flags |= UPF_EXAR_EFR;
 	/*
 	 * Setup Multipurpose Input/Output pins.
 	 */
 	if (idx == 0) {
 		writeb(0x00, p + 0x8f); /*MPIOINT[7:0]*/
 		writeb(0x00, p + 0x90); /*MPIOLVL[7:0]*/
 		writeb(0x00, p + 0x91); /*MPIO3T[7:0]*/
 		writeb(0x00, p + 0x92); /*MPIOINV[7:0]*/
 		writeb(0x00, p + 0x93); /*MPIOSEL[7:0]*/
 		writeb(0x00, p + 0x94); /*MPIOOD[7:0]*/
 		writeb(0x00, p + 0x95); /*MPIOINT[15:8]*/
 		writeb(0x00, p + 0x96); /*MPIOLVL[15:8]*/
 		writeb(0x00, p + 0x97); /*MPIO3T[15:8]*/
 		writeb(0x00, p + 0x98); /*MPIOINV[15:8]*/
 		writeb(0x00, p + 0x99); /*MPIOSEL[15:8]*/
 		writeb(0x00, p + 0x9a); /*MPIOOD[15:8]*/
 	}
 	writeb(0x00, p + UART_EXAR_8XMODE);
 	writeb(UART_FCTR_EXAR_TRGD, p + UART_EXAR_FCTR);
 	writeb(128, p + UART_EXAR_TXTRG);
 	writeb(128, p + UART_EXAR_RXTRG);
 	iounmap(p);
 	return pci_default_setup(priv, board, port, idx);
 }
 #define PCI_DEVICE_ID_COMMTECH_4222PCI335 0x0004
 #define PCI_DEVICE_ID_COMMTECH_4224PCI335 0x0002
 #define PCI_DEVICE_ID_COMMTECH_2324PCI335 0x000a
 #define PCI_DEVICE_ID_COMMTECH_2328PCI335 0x000b
 static int
 pci_fastcom335_setup(struct serial_private *priv,
 		  const struct pciserial_board *board,
 		  struct uart_8250_port *port, int idx)
 {
 	u8 __iomem *p;
 	p = pci_ioremap_bar(priv->dev, 0);
 	if (p == NULL)
 		return -ENOMEM;
 	port->port.flags |= UPF_EXAR_EFR;
 	/*
 	 * Setup Multipurpose Input/Output pins.
 	 */
 	if (idx == 0) {
 		switch (priv->dev->device) {
 		case PCI_DEVICE_ID_COMMTECH_4222PCI335:
 		case PCI_DEVICE_ID_COMMTECH_4224PCI335:
 			writeb(0x78, p + 0x90); /* MPIOLVL[7:0] */
 			writeb(0x00, p + 0x92); /* MPIOINV[7:0] */
 			writeb(0x00, p + 0x93); /* MPIOSEL[7:0] */
 			break;
 		case PCI_DEVICE_ID_COMMTECH_2324PCI335:
 		case PCI_DEVICE_ID_COMMTECH_2328PCI335:
 			writeb(0x00, p + 0x90); /* MPIOLVL[7:0] */
 			writeb(0xc0, p + 0x92); /* MPIOINV[7:0] */
 			writeb(0xc0, p + 0x93); /* MPIOSEL[7:0] */
 			break;
 		}
 		writeb(0x00, p + 0x8f); /* MPIOINT[7:0] */
 		writeb(0x00, p + 0x91); /* MPIO3T[7:0] */
 		writeb(0x00, p + 0x94); /* MPIOOD[7:0] */
 	}
 	writeb(0x00, p + UART_EXAR_8XMODE);
 	writeb(UART_FCTR_EXAR_TRGD, p + UART_EXAR_FCTR);
 	writeb(32, p + UART_EXAR_TXTRG);
 	writeb(32, p + UART_EXAR_RXTRG);
 	iounmap(p);
 	return pci_default_setup(priv, board, port, idx);
 }
 static int
 pci_wch_ch353_setup(struct serial_private *priv,
                     const struct pciserial_board *board,
                     struct uart_8250_port *port, int idx)
 {
 	port->port.flags |= UPF_FIXED_TYPE;
 	port->port.type = PORT_16550A;
 	return pci_default_setup(priv, board, port, idx);
 }
 static int
 pci_wch_ch38x_setup(struct serial_private *priv,
                     const struct pciserial_board *board,
                     struct uart_8250_port *port, int idx)
 {
 	port->port.flags |= UPF_FIXED_TYPE;
 	port->port.type = PORT_16850;
 	return pci_default_setup(priv, board, port, idx);
 }
 #define PCI_VENDOR_ID_SBSMODULARIO	0x124B
 #define PCI_SUBVENDOR_ID_SBSMODULARIO	0x124B
 #define PCI_DEVICE_ID_OCTPRO		0x0001
 #define PCI_SUBDEVICE_ID_OCTPRO232	0x0108
 #define PCI_SUBDEVICE_ID_OCTPRO422	0x0208
 #define PCI_SUBDEVICE_ID_POCTAL232	0x0308
 #define PCI_SUBDEVICE_ID_POCTAL422	0x0408
 #define PCI_SUBDEVICE_ID_SIIG_DUAL_00	0x2500
 #define PCI_SUBDEVICE_ID_SIIG_DUAL_30	0x2530
 #define PCI_VENDOR_ID_ADVANTECH		0x13fe
 #define PCI_DEVICE_ID_INTEL_CE4100_UART 0x2e66
 #define PCI_DEVICE_ID_ADVANTECH_PCI3620	0x3620
 #define PCI_DEVICE_ID_ADVANTECH_PCI3618	0x3618
 #define PCI_DEVICE_ID_ADVANTECH_PCIf618	0xf618
 #define PCI_DEVICE_ID_TITAN_200I	0x8028
 #define PCI_DEVICE_ID_TITAN_400I	0x8048
 #define PCI_DEVICE_ID_TITAN_800I	0x8088
 #define PCI_DEVICE_ID_TITAN_800EH	0xA007
 #define PCI_DEVICE_ID_TITAN_800EHB	0xA008
 #define PCI_DEVICE_ID_TITAN_400EH	0xA009
 #define PCI_DEVICE_ID_TITAN_100E	0xA010
 #define PCI_DEVICE_ID_TITAN_200E	0xA012
 #define PCI_DEVICE_ID_TITAN_400E	0xA013
 #define PCI_DEVICE_ID_TITAN_800E	0xA014
 #define PCI_DEVICE_ID_TITAN_200EI	0xA016
 #define PCI_DEVICE_ID_TITAN_200EISI	0xA017
 #define PCI_DEVICE_ID_TITAN_200V3	0xA306
 #define PCI_DEVICE_ID_TITAN_400V3	0xA310
 #define PCI_DEVICE_ID_TITAN_410V3	0xA312
 #define PCI_DEVICE_ID_TITAN_800V3	0xA314
 #define PCI_DEVICE_ID_TITAN_800V3B	0xA315
 #define PCI_DEVICE_ID_OXSEMI_16PCI958	0x9538
 #define PCIE_DEVICE_ID_NEO_2_OX_IBM	0x00F6
 #define PCI_DEVICE_ID_PLX_CRONYX_OMEGA	0xc001
 #define PCI_DEVICE_ID_INTEL_PATSBURG_KT 0x1d3d
 #define PCI_VENDOR_ID_WCH		0x4348
 #define PCI_DEVICE_ID_WCH_CH352_2S	0x3253
 #define PCI_DEVICE_ID_WCH_CH353_4S	0x3453
 #define PCI_DEVICE_ID_WCH_CH353_2S1PF	0x5046
 #define PCI_DEVICE_ID_WCH_CH353_1S1P	0x5053
 #define PCI_DEVICE_ID_WCH_CH353_2S1P	0x7053
 #define PCI_VENDOR_ID_AGESTAR		0x5372
 #define PCI_DEVICE_ID_AGESTAR_9375	0x6872
 #define PCI_VENDOR_ID_ASIX		0x9710
 #define PCI_DEVICE_ID_COMMTECH_4224PCIE	0x0020
 #define PCI_DEVICE_ID_COMMTECH_4228PCIE	0x0021
 #define PCI_DEVICE_ID_COMMTECH_4222PCIE	0x0022
 #define PCI_DEVICE_ID_BROADCOM_TRUMANAGE 0x160a
 #define PCI_DEVICE_ID_AMCC_ADDIDATA_APCI7800 0x818e
 #define PCI_DEVICE_ID_INTEL_QRK_UART	0x0936
 #define PCI_VENDOR_ID_SUNIX		0x1fd4
 #define PCI_DEVICE_ID_SUNIX_1999	0x1999
 #define PCIE_VENDOR_ID_WCH		0x1c00
 #define PCIE_DEVICE_ID_WCH_CH382_2S1P	0x3250
 #define PCIE_DEVICE_ID_WCH_CH384_4S	0x3470
 /* Unknown vendors/cards - this should not be in linux/pci_ids.h */
 #define PCI_SUBDEVICE_ID_UNKNOWN_0x1584	0x1584
 #define PCI_SUBDEVICE_ID_UNKNOWN_0x1588	0x1588
 /*
  * Master list of serial port init/setup/exit quirks.
  * This does not describe the general nature of the port.
  * (ie, baud base, number and location of ports, etc)
  *
  * This list is ordered alphabetically by vendor then device.
  * Specific entries must come before more generic entries.
  */
 static struct pci_serial_quirk pci_serial_quirks[] __refdata = {
 	/*
 	* ADDI-DATA GmbH communication cards <info@addi-data.com>
 	*/
 	{
 		.vendor         = PCI_VENDOR_ID_AMCC,
 		.device         = PCI_DEVICE_ID_AMCC_ADDIDATA_APCI7800,
 		.subvendor      = PCI_ANY_ID,
 		.subdevice      = PCI_ANY_ID,
 		.setup          = addidata_apci7800_setup,
 	},
 	/*
 	 * AFAVLAB cards - these may be called via parport_serial
 	 *  It is not clear whether this applies to all products.
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_AFAVLAB,
 		.device		= PCI_ANY_ID,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= afavlab_setup,
 	},
 	/*
 	 * HP Diva
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_HP,
 		.device		= PCI_DEVICE_ID_HP_DIVA,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_hp_diva_init,
 		.setup		= pci_hp_diva_setup,
 	},
 	/*
 	 * Intel
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_INTEL,
 		.device		= PCI_DEVICE_ID_INTEL_80960_RP,
 		.subvendor	= 0xe4bf,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_inteli960ni_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_INTEL,
 		.device		= PCI_DEVICE_ID_INTEL_8257X_SOL,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= skip_tx_en_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_INTEL,
 		.device		= PCI_DEVICE_ID_INTEL_82573L_SOL,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= skip_tx_en_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_INTEL,
 		.device		= PCI_DEVICE_ID_INTEL_82573E_SOL,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= skip_tx_en_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_INTEL,
 		.device		= PCI_DEVICE_ID_INTEL_CE4100_UART,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= ce4100_serial_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_INTEL,
 		.device		= PCI_DEVICE_ID_INTEL_PATSBURG_KT,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= kt_serial_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_INTEL,
 		.device		= PCI_DEVICE_ID_INTEL_BYT_UART1,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= byt_serial_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_INTEL,
 		.device		= PCI_DEVICE_ID_INTEL_BYT_UART2,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= byt_serial_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_INTEL,
-		.device		= PCI_DEVICE_ID_INTEL_QRK_UART,
-		.subvendor	= PCI_ANY_ID,
-		.subdevice	= PCI_ANY_ID,
-		.setup		= pci_default_setup,
-	},
-	{
-		.vendor		= PCI_VENDOR_ID_INTEL,
 		.device		= PCI_DEVICE_ID_INTEL_BSW_UART1,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= byt_serial_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_INTEL,
 		.device		= PCI_DEVICE_ID_INTEL_BSW_UART2,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= byt_serial_setup,
 	},
 	/*
 	 * ITE
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_ITE,
 		.device		= PCI_DEVICE_ID_ITE_8872,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ite887x_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ite887x_exit,
 	},
 	/*
 	 * National Instruments
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PCI23216,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PCI2328,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PCI2324,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PCI2322,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PCI2324I,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PCI2322I,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PXI8420_23216,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PXI8420_2328,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PXI8420_2324,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PXI8420_2322,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PXI8422_2324,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_DEVICE_ID_NI_PXI8422_2322,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8420_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_ni8420_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_NI,
 		.device		= PCI_ANY_ID,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_ni8430_init,
 		.setup		= pci_ni8430_setup,
 		.exit		= pci_ni8430_exit,
 	},
 	/* Quatech */
 	{
 		.vendor		= PCI_VENDOR_ID_QUATECH,
 		.device		= PCI_ANY_ID,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_quatech_init,
 		.setup		= pci_quatech_setup,
 		.exit		= pci_quatech_exit,
 	},
 	/*
 	 * Panacom
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_PANACOM,
 		.device		= PCI_DEVICE_ID_PANACOM_QUADMODEM,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_plx9050_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_plx9050_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_PANACOM,
 		.device		= PCI_DEVICE_ID_PANACOM_DUALMODEM,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_plx9050_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_plx9050_exit,
 	},
 	/*
 	 * Pericom
 	 */
 	{
 		.vendor		= 0x12d8,
 		.device		= 0x7952,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_pericom_setup,
 	},
 	{
 		.vendor		= 0x12d8,
 		.device		= 0x7954,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_pericom_setup,
 	},
 	{
 		.vendor		= 0x12d8,
 		.device		= 0x7958,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_pericom_setup,
 	},
 	/*
 	 * PLX
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_PLX,
-		.device		= PCI_DEVICE_ID_PLX_9030,
-		.subvendor	= PCI_SUBVENDOR_ID_PERLE,
-		.subdevice	= PCI_ANY_ID,
-		.setup		= pci_default_setup,
-	},
-	{
-		.vendor		= PCI_VENDOR_ID_PLX,
 		.device		= PCI_DEVICE_ID_PLX_9050,
 		.subvendor	= PCI_SUBVENDOR_ID_EXSYS,
 		.subdevice	= PCI_SUBDEVICE_ID_EXSYS_4055,
 		.init		= pci_plx9050_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_plx9050_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_PLX,
 		.device		= PCI_DEVICE_ID_PLX_9050,
 		.subvendor	= PCI_SUBVENDOR_ID_KEYSPAN,
 		.subdevice	= PCI_SUBDEVICE_ID_KEYSPAN_SX2,
 		.init		= pci_plx9050_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_plx9050_exit,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_PLX,
 		.device		= PCI_DEVICE_ID_PLX_ROMULUS,
 		.subvendor	= PCI_VENDOR_ID_PLX,
 		.subdevice	= PCI_DEVICE_ID_PLX_ROMULUS,
 		.init		= pci_plx9050_init,
 		.setup		= pci_default_setup,
 		.exit		= pci_plx9050_exit,
 	},
 	/*
 	 * SBS Technologies, Inc., PMC-OCTALPRO 232
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_SBSMODULARIO,
 		.device		= PCI_DEVICE_ID_OCTPRO,
 		.subvendor	= PCI_SUBVENDOR_ID_SBSMODULARIO,
 		.subdevice	= PCI_SUBDEVICE_ID_OCTPRO232,
 		.init		= sbs_init,
 		.setup		= sbs_setup,
 		.exit		= sbs_exit,
 	},
 	/*
 	 * SBS Technologies, Inc., PMC-OCTALPRO 422
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_SBSMODULARIO,
 		.device		= PCI_DEVICE_ID_OCTPRO,
 		.subvendor	= PCI_SUBVENDOR_ID_SBSMODULARIO,
 		.subdevice	= PCI_SUBDEVICE_ID_OCTPRO422,
 		.init		= sbs_init,
 		.setup		= sbs_setup,
 		.exit		= sbs_exit,
 	},
 	/*
 	 * SBS Technologies, Inc., P-Octal 232
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_SBSMODULARIO,
 		.device		= PCI_DEVICE_ID_OCTPRO,
 		.subvendor	= PCI_SUBVENDOR_ID_SBSMODULARIO,
 		.subdevice	= PCI_SUBDEVICE_ID_POCTAL232,
 		.init		= sbs_init,
 		.setup		= sbs_setup,
 		.exit		= sbs_exit,
 	},
 	/*
 	 * SBS Technologies, Inc., P-Octal 422
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_SBSMODULARIO,
 		.device		= PCI_DEVICE_ID_OCTPRO,
 		.subvendor	= PCI_SUBVENDOR_ID_SBSMODULARIO,
 		.subdevice	= PCI_SUBDEVICE_ID_POCTAL422,
 		.init		= sbs_init,
 		.setup		= sbs_setup,
 		.exit		= sbs_exit,
 	},
 	/*
 	 * SIIG cards - these may be called via parport_serial
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_SIIG,
 		.device		= PCI_ANY_ID,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_siig_init,
 		.setup		= pci_siig_setup,
 	},
 	/*
 	 * Titan cards
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_TITAN,
 		.device		= PCI_DEVICE_ID_TITAN_400L,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= titan_400l_800l_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_TITAN,
 		.device		= PCI_DEVICE_ID_TITAN_800L,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= titan_400l_800l_setup,
 	},
 	/*
 	 * Timedia cards
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_TIMEDIA,
 		.device		= PCI_DEVICE_ID_TIMEDIA_1889,
 		.subvendor	= PCI_VENDOR_ID_TIMEDIA,
 		.subdevice	= PCI_ANY_ID,
 		.probe		= pci_timedia_probe,
 		.init		= pci_timedia_init,
 		.setup		= pci_timedia_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_TIMEDIA,
 		.device		= PCI_ANY_ID,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_timedia_setup,
 	},
 	/*
 	 * SUNIX (Timedia) cards
 	 * Do not "probe" for these cards as there is at least one combination
 	 * card that should be handled by parport_pc that doesn't match the
 	 * rule in pci_timedia_probe.
 	 * It is part number is MIO5079A but its subdevice ID is 0x0102.
 	 * There are some boards with part number SER5037AL that report
 	 * subdevice ID 0x0002.
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_SUNIX,
 		.device		= PCI_DEVICE_ID_SUNIX_1999,
 		.subvendor	= PCI_VENDOR_ID_SUNIX,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_timedia_init,
 		.setup		= pci_timedia_setup,
 	},
 	/*
 	 * Exar cards
 	 */
 	{
 		.vendor = PCI_VENDOR_ID_EXAR,
 		.device = PCI_DEVICE_ID_EXAR_XR17C152,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_xr17c154_setup,
 	},
 	{
 		.vendor = PCI_VENDOR_ID_EXAR,
 		.device = PCI_DEVICE_ID_EXAR_XR17C154,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_xr17c154_setup,
 	},
 	{
 		.vendor = PCI_VENDOR_ID_EXAR,
 		.device = PCI_DEVICE_ID_EXAR_XR17C158,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_xr17c154_setup,
 	},
 	{
 		.vendor = PCI_VENDOR_ID_EXAR,
 		.device = PCI_DEVICE_ID_EXAR_XR17V352,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_xr17v35x_setup,
 	},
 	{
 		.vendor = PCI_VENDOR_ID_EXAR,
 		.device = PCI_DEVICE_ID_EXAR_XR17V354,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_xr17v35x_setup,
 	},
 	{
 		.vendor = PCI_VENDOR_ID_EXAR,
 		.device = PCI_DEVICE_ID_EXAR_XR17V358,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_xr17v35x_setup,
 	},
 	/*
 	 * Xircom cards
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_XIRCOM,
 		.device		= PCI_DEVICE_ID_XIRCOM_X3201_MDM,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_xircom_init,
 		.setup		= pci_default_setup,
 	},
 	/*
 	 * Netmos cards - these may be called via parport_serial
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_NETMOS,
 		.device		= PCI_ANY_ID,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_netmos_init,
 		.setup		= pci_netmos_9900_setup,
 	},
 	/*
 	 * EndRun Technologies
 	*/
 	{
 		.vendor		= PCI_VENDOR_ID_ENDRUN,
 		.device		= PCI_ANY_ID,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_endrun_init,
 		.setup		= pci_default_setup,
 	},
 	/*
 	 * For Oxford Semiconductor Tornado based devices
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_OXSEMI,
 		.device		= PCI_ANY_ID,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_oxsemi_tornado_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_MAINPINE,
 		.device		= PCI_ANY_ID,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_oxsemi_tornado_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor		= PCI_VENDOR_ID_DIGI,
 		.device		= PCIE_DEVICE_ID_NEO_2_OX_IBM,
 		.subvendor		= PCI_SUBVENDOR_ID_IBM,
 		.subdevice		= PCI_ANY_ID,
 		.init			= pci_oxsemi_tornado_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = PCI_VENDOR_ID_INTEL,
 		.device         = 0x8811,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_eg20t_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = PCI_VENDOR_ID_INTEL,
 		.device         = 0x8812,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_eg20t_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = PCI_VENDOR_ID_INTEL,
 		.device         = 0x8813,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_eg20t_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = PCI_VENDOR_ID_INTEL,
 		.device         = 0x8814,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_eg20t_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = 0x10DB,
 		.device         = 0x8027,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_eg20t_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = 0x10DB,
 		.device         = 0x8028,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_eg20t_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = 0x10DB,
 		.device         = 0x8029,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_eg20t_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = 0x10DB,
 		.device         = 0x800C,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_eg20t_init,
 		.setup		= pci_default_setup,
 	},
 	{
 		.vendor         = 0x10DB,
 		.device         = 0x800D,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.init		= pci_eg20t_init,
 		.setup		= pci_default_setup,
 	},
 	/*
 	 * Cronyx Omega PCI (PLX-chip based)
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_PLX,
 		.device		= PCI_DEVICE_ID_PLX_CRONYX_OMEGA,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_omegapci_setup,
 	},
 	/* WCH CH353 1S1P card (16550 clone) */
 	{
 		.vendor         = PCI_VENDOR_ID_WCH,
 		.device         = PCI_DEVICE_ID_WCH_CH353_1S1P,
 		.subvendor      = PCI_ANY_ID,
 		.subdevice      = PCI_ANY_ID,
 		.setup          = pci_wch_ch353_setup,
 	},
 	/* WCH CH353 2S1P card (16550 clone) */
 	{
 		.vendor         = PCI_VENDOR_ID_WCH,
 		.device         = PCI_DEVICE_ID_WCH_CH353_2S1P,
 		.subvendor      = PCI_ANY_ID,
 		.subdevice      = PCI_ANY_ID,
 		.setup          = pci_wch_ch353_setup,
 	},
 	/* WCH CH353 4S card (16550 clone) */
 	{
 		.vendor         = PCI_VENDOR_ID_WCH,
 		.device         = PCI_DEVICE_ID_WCH_CH353_4S,
 		.subvendor      = PCI_ANY_ID,
 		.subdevice      = PCI_ANY_ID,
 		.setup          = pci_wch_ch353_setup,
 	},
 	/* WCH CH353 2S1PF card (16550 clone) */
 	{
 		.vendor         = PCI_VENDOR_ID_WCH,
 		.device         = PCI_DEVICE_ID_WCH_CH353_2S1PF,
 		.subvendor      = PCI_ANY_ID,
 		.subdevice      = PCI_ANY_ID,
 		.setup          = pci_wch_ch353_setup,
 	},
 	/* WCH CH352 2S card (16550 clone) */
 	{
 		.vendor		= PCI_VENDOR_ID_WCH,
 		.device		= PCI_DEVICE_ID_WCH_CH352_2S,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_wch_ch353_setup,
 	},
 	/* WCH CH382 2S1P card (16850 clone) */
 	{
 		.vendor         = PCIE_VENDOR_ID_WCH,
 		.device         = PCIE_DEVICE_ID_WCH_CH382_2S1P,
 		.subvendor      = PCI_ANY_ID,
 		.subdevice      = PCI_ANY_ID,
 		.setup          = pci_wch_ch38x_setup,
 	},
 	/* WCH CH384 4S card (16850 clone) */
 	{
 		.vendor         = PCIE_VENDOR_ID_WCH,
 		.device         = PCIE_DEVICE_ID_WCH_CH384_4S,
 		.subvendor      = PCI_ANY_ID,
 		.subdevice      = PCI_ANY_ID,
 		.setup          = pci_wch_ch38x_setup,
 	},
 	/*
 	 * ASIX devices with FIFO bug
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_ASIX,
 		.device		= PCI_ANY_ID,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_asix_setup,
 	},
 	/*
 	 * Commtech, Inc. Fastcom adapters
 	 *
 	 */
 	{
 		.vendor = PCI_VENDOR_ID_COMMTECH,
 		.device = PCI_DEVICE_ID_COMMTECH_4222PCI335,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_fastcom335_setup,
 	},
 	{
 		.vendor = PCI_VENDOR_ID_COMMTECH,
 		.device = PCI_DEVICE_ID_COMMTECH_4224PCI335,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_fastcom335_setup,
 	},
 	{
 		.vendor = PCI_VENDOR_ID_COMMTECH,
 		.device = PCI_DEVICE_ID_COMMTECH_2324PCI335,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_fastcom335_setup,
 	},
 	{
 		.vendor = PCI_VENDOR_ID_COMMTECH,
 		.device = PCI_DEVICE_ID_COMMTECH_2328PCI335,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_fastcom335_setup,
 	},
 	{
 		.vendor = PCI_VENDOR_ID_COMMTECH,
 		.device = PCI_DEVICE_ID_COMMTECH_4222PCIE,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_xr17v35x_setup,
 	},
 	{
 		.vendor = PCI_VENDOR_ID_COMMTECH,
 		.device = PCI_DEVICE_ID_COMMTECH_4224PCIE,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_xr17v35x_setup,
 	},
 	{
 		.vendor = PCI_VENDOR_ID_COMMTECH,
 		.device = PCI_DEVICE_ID_COMMTECH_4228PCIE,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_xr17v35x_setup,
 	},
 	/*
 	 * Broadcom TruManage (NetXtreme)
 	 */
 	{
 		.vendor		= PCI_VENDOR_ID_BROADCOM,
 		.device		= PCI_DEVICE_ID_BROADCOM_TRUMANAGE,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_brcm_trumanage_setup,
 	},
 	{
 		.vendor		= 0x1c29,
 		.device		= 0x1104,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_fintek_setup,
 	},
 	{
 		.vendor		= 0x1c29,
 		.device		= 0x1108,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_fintek_setup,
 	},
 	{
 		.vendor		= 0x1c29,
 		.device		= 0x1112,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_fintek_setup,
 	},
 	/*
 	 * Default "match everything" terminator entry
 	 */
 	{
 		.vendor		= PCI_ANY_ID,
 		.device		= PCI_ANY_ID,
 		.subvendor	= PCI_ANY_ID,
 		.subdevice	= PCI_ANY_ID,
 		.setup		= pci_default_setup,
 	}
 };
 static inline int quirk_id_matches(u32 quirk_id, u32 dev_id)
 {
 	return quirk_id == PCI_ANY_ID || quirk_id == dev_id;
 }
 static struct pci_serial_quirk *find_quirk(struct pci_dev *dev)
 {
 	struct pci_serial_quirk *quirk;
 	for (quirk = pci_serial_quirks; ; quirk++)
 		if (quirk_id_matches(quirk->vendor, dev->vendor) &&
 		    quirk_id_matches(quirk->device, dev->device) &&
 		    quirk_id_matches(quirk->subvendor, dev->subsystem_vendor) &&
 		    quirk_id_matches(quirk->subdevice, dev->subsystem_device))
 			break;
 	return quirk;
 }
 static inline int get_pci_irq(struct pci_dev *dev,
 				const struct pciserial_board *board)
 {
 	if (board->flags & FL_NOIRQ)
 		return 0;
 	else
 		return dev->irq;
 }
 /*
  * This is the configuration table for all of the PCI serial boards
  * which we support.  It is directly indexed by the pci_board_num_t enum
  * value, which is encoded in the pci_device_id PCI probe table's
  * driver_data member.
  *
  * The makeup of these names are:
  *  pbn_bn{_bt}_n_baud{_offsetinhex}
  *
  *  bn		= PCI BAR number
  *  bt		= Index using PCI BARs
  *  n		= number of serial ports
  *  baud	= baud rate
  *  offsetinhex	= offset for each sequential port (in hex)
  *
  * This table is sorted by (in order): bn, bt, baud, offsetindex, n.
  *
  * Please note: in theory if n = 1, _bt infix should make no difference.
  * ie, pbn_b0_1_115200 is the same as pbn_b0_bt_1_115200
  */
 enum pci_board_num_t {
 	pbn_default = 0,
 	pbn_b0_1_115200,
 	pbn_b0_2_115200,
 	pbn_b0_4_115200,
 	pbn_b0_5_115200,
 	pbn_b0_8_115200,
 	pbn_b0_1_921600,
 	pbn_b0_2_921600,
 	pbn_b0_4_921600,
 	pbn_b0_2_1130000,
 	pbn_b0_4_1152000,
 	pbn_b0_2_1152000_200,
 	pbn_b0_4_1152000_200,
 	pbn_b0_8_1152000_200,
 	pbn_b0_2_1843200,
 	pbn_b0_4_1843200,
 	pbn_b0_2_1843200_200,
 	pbn_b0_4_1843200_200,
 	pbn_b0_8_1843200_200,
 	pbn_b0_1_4000000,
 	pbn_b0_bt_1_115200,
 	pbn_b0_bt_2_115200,
 	pbn_b0_bt_4_115200,
 	pbn_b0_bt_8_115200,
 	pbn_b0_bt_1_460800,
 	pbn_b0_bt_2_460800,
 	pbn_b0_bt_4_460800,
 	pbn_b0_bt_1_921600,
 	pbn_b0_bt_2_921600,
 	pbn_b0_bt_4_921600,
 	pbn_b0_bt_8_921600,
 	pbn_b1_1_115200,
 	pbn_b1_2_115200,
 	pbn_b1_4_115200,
 	pbn_b1_8_115200,
 	pbn_b1_16_115200,
 	pbn_b1_1_921600,
 	pbn_b1_2_921600,
 	pbn_b1_4_921600,
 	pbn_b1_8_921600,
 	pbn_b1_2_1250000,
 	pbn_b1_bt_1_115200,
 	pbn_b1_bt_2_115200,
 	pbn_b1_bt_4_115200,
 	pbn_b1_bt_2_921600,
 	pbn_b1_1_1382400,
 	pbn_b1_2_1382400,
 	pbn_b1_4_1382400,
 	pbn_b1_8_1382400,
 	pbn_b2_1_115200,
 	pbn_b2_2_115200,
 	pbn_b2_4_115200,
 	pbn_b2_8_115200,
 	pbn_b2_1_460800,
 	pbn_b2_4_460800,
 	pbn_b2_8_460800,
 	pbn_b2_16_460800,
 	pbn_b2_1_921600,
 	pbn_b2_4_921600,
 	pbn_b2_8_921600,
 	pbn_b2_8_1152000,
 	pbn_b2_bt_1_115200,
 	pbn_b2_bt_2_115200,
 	pbn_b2_bt_4_115200,
 	pbn_b2_bt_2_921600,
 	pbn_b2_bt_4_921600,
 	pbn_b3_2_115200,
 	pbn_b3_4_115200,
 	pbn_b3_8_115200,
 	pbn_b4_bt_2_921600,
 	pbn_b4_bt_4_921600,
 	pbn_b4_bt_8_921600,
 	/*
 	 * Board-specific versions.
 	 */
 	pbn_panacom,
 	pbn_panacom2,
 	pbn_panacom4,
 	pbn_plx_romulus,
 	pbn_endrun_2_4000000,
 	pbn_oxsemi,
 	pbn_oxsemi_1_4000000,
 	pbn_oxsemi_2_4000000,
 	pbn_oxsemi_4_4000000,
 	pbn_oxsemi_8_4000000,
 	pbn_intel_i960,
 	pbn_sgi_ioc3,
 	pbn_computone_4,
 	pbn_computone_6,
 	pbn_computone_8,
 	pbn_sbsxrsio,
 	pbn_exar_XR17C152,
 	pbn_exar_XR17C154,
 	pbn_exar_XR17C158,
 	pbn_exar_XR17V352,
 	pbn_exar_XR17V354,
 	pbn_exar_XR17V358,
 	pbn_exar_ibm_saturn,
 	pbn_pasemi_1682M,
 	pbn_ni8430_2,
 	pbn_ni8430_4,
 	pbn_ni8430_8,
 	pbn_ni8430_16,
 	pbn_ADDIDATA_PCIe_1_3906250,
 	pbn_ADDIDATA_PCIe_2_3906250,
 	pbn_ADDIDATA_PCIe_4_3906250,
 	pbn_ADDIDATA_PCIe_8_3906250,
 	pbn_ce4100_1_115200,
 	pbn_byt,
 	pbn_qrk,
 	pbn_omegapci,
 	pbn_NETMOS9900_2s_115200,
 	pbn_brcm_trumanage,
 	pbn_fintek_4,
 	pbn_fintek_8,
 	pbn_fintek_12,
 	pbn_wch384_4,
 };
 /*
  * uart_offset - the space between channels
  * reg_shift   - describes how the UART registers are mapped
  *               to PCI memory by the card.
  * For example IER register on SBS, Inc. PMC-OctPro is located at
  * offset 0x10 from the UART base, while UART_IER is defined as 1
  * in include/linux/serial_reg.h,
  * see first lines of serial_in() and serial_out() in 8250.c
 */
 static struct pciserial_board pci_boards[] = {
 	[pbn_default] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 1,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_1_115200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 1,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_2_115200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_4_115200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_5_115200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 5,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_8_115200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 8,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_1_921600] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 1,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_2_921600] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_4_921600] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_2_1130000] = {
 		.flags          = FL_BASE0,
 		.num_ports      = 2,
 		.base_baud      = 1130000,
 		.uart_offset    = 8,
 	},
 	[pbn_b0_4_1152000] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 1152000,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_2_1152000_200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 1152000,
 		.uart_offset	= 0x200,
 	},
 	[pbn_b0_4_1152000_200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 1152000,
 		.uart_offset	= 0x200,
 	},
 	[pbn_b0_8_1152000_200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 8,
 		.base_baud	= 1152000,
 		.uart_offset	= 0x200,
 	},
 	[pbn_b0_2_1843200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 1843200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_4_1843200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 1843200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_2_1843200_200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 1843200,
 		.uart_offset	= 0x200,
 	},
 	[pbn_b0_4_1843200_200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 1843200,
 		.uart_offset	= 0x200,
 	},
 	[pbn_b0_8_1843200_200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 8,
 		.base_baud	= 1843200,
 		.uart_offset	= 0x200,
 	},
 	[pbn_b0_1_4000000] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 1,
 		.base_baud	= 4000000,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_bt_1_115200] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 1,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_bt_2_115200] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 2,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_bt_4_115200] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 4,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_bt_8_115200] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 8,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_bt_1_460800] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 1,
 		.base_baud	= 460800,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_bt_2_460800] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 2,
 		.base_baud	= 460800,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_bt_4_460800] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 4,
 		.base_baud	= 460800,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_bt_1_921600] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 1,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_bt_2_921600] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 2,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_bt_4_921600] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 4,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b0_bt_8_921600] = {
 		.flags		= FL_BASE0|FL_BASE_BARS,
 		.num_ports	= 8,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_1_115200] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 1,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_2_115200] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 2,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_4_115200] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 4,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_8_115200] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 8,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_16_115200] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 16,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_1_921600] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 1,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_2_921600] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 2,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_4_921600] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 4,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_8_921600] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 8,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_2_1250000] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 2,
 		.base_baud	= 1250000,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_bt_1_115200] = {
 		.flags		= FL_BASE1|FL_BASE_BARS,
 		.num_ports	= 1,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_bt_2_115200] = {
 		.flags		= FL_BASE1|FL_BASE_BARS,
 		.num_ports	= 2,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_bt_4_115200] = {
 		.flags		= FL_BASE1|FL_BASE_BARS,
 		.num_ports	= 4,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_bt_2_921600] = {
 		.flags		= FL_BASE1|FL_BASE_BARS,
 		.num_ports	= 2,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_1_1382400] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 1,
 		.base_baud	= 1382400,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_2_1382400] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 2,
 		.base_baud	= 1382400,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_4_1382400] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 4,
 		.base_baud	= 1382400,
 		.uart_offset	= 8,
 	},
 	[pbn_b1_8_1382400] = {
 		.flags		= FL_BASE1,
 		.num_ports	= 8,
 		.base_baud	= 1382400,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_1_115200] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 1,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_2_115200] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 2,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_4_115200] = {
 		.flags          = FL_BASE2,
 		.num_ports      = 4,
 		.base_baud      = 115200,
 		.uart_offset    = 8,
 	},
 	[pbn_b2_8_115200] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 8,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_1_460800] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 1,
 		.base_baud	= 460800,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_4_460800] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 4,
 		.base_baud	= 460800,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_8_460800] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 8,
 		.base_baud	= 460800,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_16_460800] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 16,
 		.base_baud	= 460800,
 		.uart_offset	= 8,
 	 },
 	[pbn_b2_1_921600] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 1,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_4_921600] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 4,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_8_921600] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 8,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_8_1152000] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 8,
 		.base_baud	= 1152000,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_bt_1_115200] = {
 		.flags		= FL_BASE2|FL_BASE_BARS,
 		.num_ports	= 1,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_bt_2_115200] = {
 		.flags		= FL_BASE2|FL_BASE_BARS,
 		.num_ports	= 2,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_bt_4_115200] = {
 		.flags		= FL_BASE2|FL_BASE_BARS,
 		.num_ports	= 4,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_bt_2_921600] = {
 		.flags		= FL_BASE2|FL_BASE_BARS,
 		.num_ports	= 2,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b2_bt_4_921600] = {
 		.flags		= FL_BASE2|FL_BASE_BARS,
 		.num_ports	= 4,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b3_2_115200] = {
 		.flags		= FL_BASE3,
 		.num_ports	= 2,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b3_4_115200] = {
 		.flags		= FL_BASE3,
 		.num_ports	= 4,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b3_8_115200] = {
 		.flags		= FL_BASE3,
 		.num_ports	= 8,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_b4_bt_2_921600] = {
 		.flags		= FL_BASE4,
 		.num_ports	= 2,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b4_bt_4_921600] = {
 		.flags		= FL_BASE4,
 		.num_ports	= 4,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	[pbn_b4_bt_8_921600] = {
 		.flags		= FL_BASE4,
 		.num_ports	= 8,
 		.base_baud	= 921600,
 		.uart_offset	= 8,
 	},
 	/*
 	 * Entries following this are board-specific.
 	 */
 	/*
 	 * Panacom - IOMEM
 	 */
 	[pbn_panacom] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 2,
 		.base_baud	= 921600,
 		.uart_offset	= 0x400,
 		.reg_shift	= 7,
 	},
 	[pbn_panacom2] = {
 		.flags		= FL_BASE2|FL_BASE_BARS,
 		.num_ports	= 2,
 		.base_baud	= 921600,
 		.uart_offset	= 0x400,
 		.reg_shift	= 7,
 	},
 	[pbn_panacom4] = {
 		.flags		= FL_BASE2|FL_BASE_BARS,
 		.num_ports	= 4,
 		.base_baud	= 921600,
 		.uart_offset	= 0x400,
 		.reg_shift	= 7,
 	},
 	/* I think this entry is broken - the first_offset looks wrong --rmk */
 	[pbn_plx_romulus] = {
 		.flags		= FL_BASE2,
 		.num_ports	= 4,
 		.base_baud	= 921600,
 		.uart_offset	= 8 << 2,
 		.reg_shift	= 2,
 		.first_offset	= 0x03,
 	},
 	/*
 	 * EndRun Technologies
 	* Uses the size of PCI Base region 0 to
 	* signal now many ports are available
 	* 2 port 952 Uart support
 	*/
 	[pbn_endrun_2_4000000] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 4000000,
 		.uart_offset	= 0x200,
 		.first_offset	= 0x1000,
 	},
 	/*
 	 * This board uses the size of PCI Base region 0 to
 	 * signal now many ports are available
 	 */
 	[pbn_oxsemi] = {
 		.flags		= FL_BASE0|FL_REGION_SZ_CAP,
 		.num_ports	= 32,
 		.base_baud	= 115200,
 		.uart_offset	= 8,
 	},
 	[pbn_oxsemi_1_4000000] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 1,
 		.base_baud	= 4000000,
 		.uart_offset	= 0x200,
 		.first_offset	= 0x1000,
 	},
 	[pbn_oxsemi_2_4000000] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 4000000,
 		.uart_offset	= 0x200,
 		.first_offset	= 0x1000,
 	},
 	[pbn_oxsemi_4_4000000] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 4000000,
 		.uart_offset	= 0x200,
 		.first_offset	= 0x1000,
 	},
 	[pbn_oxsemi_8_4000000] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 8,
 		.base_baud	= 4000000,
 		.uart_offset	= 0x200,
 		.first_offset	= 0x1000,
 	},
 	/*
 	 * EKF addition for i960 Boards form EKF with serial port.
 	 * Max 256 ports.
 	 */
 	[pbn_intel_i960] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 32,
 		.base_baud	= 921600,
 		.uart_offset	= 8 << 2,
 		.reg_shift	= 2,
 		.first_offset	= 0x10000,
 	},
 	[pbn_sgi_ioc3] = {
 		.flags		= FL_BASE0|FL_NOIRQ,
 		.num_ports	= 1,
 		.base_baud	= 458333,
 		.uart_offset	= 8,
 		.reg_shift	= 0,
 		.first_offset	= 0x20178,
 	},
 	/*
 	 * Computone - uses IOMEM.
 	 */
 	[pbn_computone_4] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 921600,
 		.uart_offset	= 0x40,
 		.reg_shift	= 2,
 		.first_offset	= 0x200,
 	},
 	[pbn_computone_6] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 6,
 		.base_baud	= 921600,
 		.uart_offset	= 0x40,
 		.reg_shift	= 2,
 		.first_offset	= 0x200,
 	},
 	[pbn_computone_8] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 8,
 		.base_baud	= 921600,
 		.uart_offset	= 0x40,
 		.reg_shift	= 2,
 		.first_offset	= 0x200,
 	},
 	[pbn_sbsxrsio] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 8,
 		.base_baud	= 460800,
 		.uart_offset	= 256,
 		.reg_shift	= 4,
 	},
 	/*
 	 * Exar Corp. XR17C15[248] Dual/Quad/Octal UART
 	 *  Only basic 16550A support.
 	 *  XR17C15[24] are not tested, but they should work.
 	 */
 	[pbn_exar_XR17C152] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 921600,
 		.uart_offset	= 0x200,
 	},
 	[pbn_exar_XR17C154] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 921600,
 		.uart_offset	= 0x200,
 	},
 	[pbn_exar_XR17C158] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 8,
 		.base_baud	= 921600,
 		.uart_offset	= 0x200,
 	},
 	[pbn_exar_XR17V352] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 7812500,
 		.uart_offset	= 0x400,
 		.reg_shift	= 0,
 		.first_offset	= 0,
 	},
 	[pbn_exar_XR17V354] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 7812500,
 		.uart_offset	= 0x400,
 		.reg_shift	= 0,
 		.first_offset	= 0,
 	},
 	[pbn_exar_XR17V358] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 8,
 		.base_baud	= 7812500,
 		.uart_offset	= 0x400,
 		.reg_shift	= 0,
 		.first_offset	= 0,
 	},
 	[pbn_exar_ibm_saturn] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 1,
 		.base_baud	= 921600,
 		.uart_offset	= 0x200,
 	},
 	/*
 	 * PA Semi PWRficient PA6T-1682M on-chip UART
 	 */
 	[pbn_pasemi_1682M] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 1,
 		.base_baud	= 8333333,
 	},
 	/*
 	 * National Instruments 843x
 	 */
 	[pbn_ni8430_16] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 16,
 		.base_baud	= 3686400,
 		.uart_offset	= 0x10,
 		.first_offset	= 0x800,
 	},
 	[pbn_ni8430_8] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 8,
 		.base_baud	= 3686400,
 		.uart_offset	= 0x10,
 		.first_offset	= 0x800,
 	},
 	[pbn_ni8430_4] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 3686400,
 		.uart_offset	= 0x10,
 		.first_offset	= 0x800,
 	},
 	[pbn_ni8430_2] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 3686400,
 		.uart_offset	= 0x10,
 		.first_offset	= 0x800,
 	},
 	/*
 	 * ADDI-DATA GmbH PCI-Express communication cards <info@addi-data.com>
 	 */
 	[pbn_ADDIDATA_PCIe_1_3906250] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 1,
 		.base_baud	= 3906250,
 		.uart_offset	= 0x200,
 		.first_offset	= 0x1000,
 	},
 	[pbn_ADDIDATA_PCIe_2_3906250] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 3906250,
 		.uart_offset	= 0x200,
 		.first_offset	= 0x1000,
 	},
 	[pbn_ADDIDATA_PCIe_4_3906250] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud	= 3906250,
 		.uart_offset	= 0x200,
 		.first_offset	= 0x1000,
 	},
 	[pbn_ADDIDATA_PCIe_8_3906250] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 8,
 		.base_baud	= 3906250,
 		.uart_offset	= 0x200,
 		.first_offset	= 0x1000,
 	},
 	[pbn_ce4100_1_115200] = {
 		.flags		= FL_BASE_BARS,
 		.num_ports	= 2,
 		.base_baud	= 921600,
 		.reg_shift      = 2,
 	},
 	/*
 	 * Intel BayTrail HSUART reference clock is 44.2368 MHz at power-on,
 	 * but is overridden by byt_set_termios.
 	 */
 	[pbn_byt] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 1,
 		.base_baud	= 2764800,
 		.uart_offset	= 0x80,
 		.reg_shift      = 2,
 	},
 	[pbn_qrk] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 1,
 		.base_baud	= 2764800,
 		.reg_shift	= 2,
 	},
 	[pbn_omegapci] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 8,
 		.base_baud	= 115200,
 		.uart_offset	= 0x200,
 	},
 	[pbn_NETMOS9900_2s_115200] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 2,
 		.base_baud	= 115200,
 	},
 	[pbn_brcm_trumanage] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 1,
 		.reg_shift	= 2,
 		.base_baud	= 115200,
 	},
 	[pbn_fintek_4] = {
 		.num_ports	= 4,
 		.uart_offset	= 8,
 		.base_baud	= 115200,
 		.first_offset	= 0x40,
 	},
 	[pbn_fintek_8] = {
 		.num_ports	= 8,
 		.uart_offset	= 8,
 		.base_baud	= 115200,
 		.first_offset	= 0x40,
 	},
 	[pbn_fintek_12] = {
 		.num_ports	= 12,
 		.uart_offset	= 8,
 		.base_baud	= 115200,
 		.first_offset	= 0x40,
 	},
 	[pbn_wch384_4] = {
 		.flags		= FL_BASE0,
 		.num_ports	= 4,
 		.base_baud      = 115200,
 		.uart_offset    = 8,
 		.first_offset   = 0xC0,
 	},
 };
 static const struct pci_device_id blacklist[] = {
 	/* softmodems */
 	{ PCI_VDEVICE(AL, 0x5457), }, /* ALi Corporation M5457 AC'97 Modem */
 	{ PCI_VDEVICE(MOTOROLA, 0x3052), }, /* Motorola Si3052-based modem */
 	{ PCI_DEVICE(0x1543, 0x3052), }, /* Si3052-based modem, default IDs */
 	/* multi-io cards handled by parport_serial */
 	{ PCI_DEVICE(0x4348, 0x7053), }, /* WCH CH353 2S1P */
 	{ PCI_DEVICE(0x4348, 0x5053), }, /* WCH CH353 1S1P */
 	{ PCI_DEVICE(0x1c00, 0x3250), }, /* WCH CH382 2S1P */
 	{ PCI_DEVICE(0x1c00, 0x3470), }, /* WCH CH384 4S */
 };
 /*
  * Given a complete unknown PCI device, try to use some heuristics to
  * guess what the configuration might be, based on the pitiful PCI
  * serial specs.  Returns 0 on success, 1 on failure.
  */
 static int
 serial_pci_guess_board(struct pci_dev *dev, struct pciserial_board *board)
 {
 	const struct pci_device_id *bldev;
 	int num_iomem, num_port, first_port = -1, i;
 	/*
 	 * If it is not a communications device or the programming
 	 * interface is greater than 6, give up.
 	 *
 	 * (Should we try to make guesses for multiport serial devices
 	 * later?)
 	 */
 	if ((((dev->class >> 8) != PCI_CLASS_COMMUNICATION_SERIAL) &&
 	     ((dev->class >> 8) != PCI_CLASS_COMMUNICATION_MODEM)) ||
 	    (dev->class & 0xff) > 6)
 		return -ENODEV;
 	/*
 	 * Do not access blacklisted devices that are known not to
 	 * feature serial ports or are handled by other modules.
 	 */
 	for (bldev = blacklist;
 	     bldev < blacklist + ARRAY_SIZE(blacklist);
 	     bldev++) {
 		if (dev->vendor == bldev->vendor &&
 		    dev->device == bldev->device)
 			return -ENODEV;
 	}
 	num_iomem = num_port = 0;
 	for (i = 0; i < PCI_NUM_BAR_RESOURCES; i++) {
 		if (pci_resource_flags(dev, i) & IORESOURCE_IO) {
 			num_port++;
 			if (first_port == -1)
 				first_port = i;
 		}
 		if (pci_resource_flags(dev, i) & IORESOURCE_MEM)
 			num_iomem++;
 	}
 	/*
 	 * If there is 1 or 0 iomem regions, and exactly one port,
 	 * use it.  We guess the number of ports based on the IO
 	 * region size.
 	 */
 	if (num_iomem <= 1 && num_port == 1) {
 		board->flags = first_port;
 		board->num_ports = pci_resource_len(dev, first_port) / 8;
 		return 0;
 	}
 	/*
 	 * Now guess if we've got a board which indexes by BARs.
 	 * Each IO BAR should be 8 bytes, and they should follow
 	 * consecutively.
 	 */
 	first_port = -1;
 	num_port = 0;
 	for (i = 0; i < PCI_NUM_BAR_RESOURCES; i++) {
 		if (pci_resource_flags(dev, i) & IORESOURCE_IO &&
 		    pci_resource_len(dev, i) == 8 &&
 		    (first_port == -1 || (first_port + num_port) == i)) {
 			num_port++;
 			if (first_port == -1)
 				first_port = i;
 		}
 	}
 	if (num_port > 1) {
 		board->flags = first_port | FL_BASE_BARS;
 		board->num_ports = num_port;
 		return 0;
 	}
 	return -ENODEV;
 }
 static inline int
 serial_pci_matches(const struct pciserial_board *board,
 		   const struct pciserial_board *guessed)
 {
 	return
 	    board->num_ports == guessed->num_ports &&
 	    board->base_baud == guessed->base_baud &&
 	    board->uart_offset == guessed->uart_offset &&
 	    board->reg_shift == guessed->reg_shift &&
 	    board->first_offset == guessed->first_offset;
 }
 struct serial_private *
 pciserial_init_ports(struct pci_dev *dev, const struct pciserial_board *board)
 {
 	struct uart_8250_port uart;
 	struct serial_private *priv;
 	struct pci_serial_quirk *quirk;
 	int rc, nr_ports, i;
 	nr_ports = board->num_ports;
 	/*
 	 * Find an init and setup quirks.
 	 */
 	quirk = find_quirk(dev);
 	/*
 	 * Run the new-style initialization function.
 	 * The initialization function returns:
 	 *  <0  - error
 	 *   0  - use board->num_ports
 	 *  >0  - number of ports
 	 */
 	if (quirk->init) {
 		rc = quirk->init(dev);
 		if (rc < 0) {
 			priv = ERR_PTR(rc);
 			goto err_out;
 		}
 		if (rc)
 			nr_ports = rc;
 	}
 	priv = kzalloc(sizeof(struct serial_private) +
 		       sizeof(unsigned int) * nr_ports,
 		       GFP_KERNEL);
 	if (!priv) {
 		priv = ERR_PTR(-ENOMEM);
 		goto err_deinit;
 	}
 	priv->dev = dev;
 	priv->quirk = quirk;
 	memset(&uart, 0, sizeof(uart));
 	uart.port.flags = UPF_SKIP_TEST | UPF_BOOT_AUTOCONF | UPF_SHARE_IRQ;
 	uart.port.uartclk = board->base_baud * 16;
 	uart.port.irq = get_pci_irq(dev, board);
 	uart.port.dev = &dev->dev;
 	for (i = 0; i < nr_ports; i++) {
 		if (quirk->setup(priv, board, &uart, i))
 			break;
 		dev_dbg(&dev->dev, "Setup PCI port: port %lx, irq %d, type %d\n",
 			uart.port.iobase, uart.port.irq, uart.port.iotype);
 		priv->line[i] = serial8250_register_8250_port(&uart);
 		if (priv->line[i] < 0) {
 			dev_err(&dev->dev,
 				"Couldn't register serial port %lx, irq %d, type %d, error %d\n",
 				uart.port.iobase, uart.port.irq,
 				uart.port.iotype, priv->line[i]);
 			break;
 		}
 	}
 	priv->nr = i;
 	return priv;
 err_deinit:
 	if (quirk->exit)
 		quirk->exit(dev);
 err_out:
 	return priv;
 }
 EXPORT_SYMBOL_GPL(pciserial_init_ports);
 void pciserial_remove_ports(struct serial_private *priv)
 {
 	struct pci_serial_quirk *quirk;
 	int i;
 	for (i = 0; i < priv->nr; i++)
 		serial8250_unregister_port(priv->line[i]);
 	for (i = 0; i < PCI_NUM_BAR_RESOURCES; i++) {
 		if (priv->remapped_bar[i])
 			iounmap(priv->remapped_bar[i]);
 		priv->remapped_bar[i] = NULL;
 	}
 	/*
 	 * Find the exit quirks.
 	 */
 	quirk = find_quirk(priv->dev);
 	if (quirk->exit)
 		quirk->exit(priv->dev);
 	kfree(priv);
 }
 EXPORT_SYMBOL_GPL(pciserial_remove_ports);
 void pciserial_suspend_ports(struct serial_private *priv)
 {
 	int i;
 	for (i = 0; i < priv->nr; i++)
 		if (priv->line[i] >= 0)
 			serial8250_suspend_port(priv->line[i]);
 	/*
 	 * Ensure that every init quirk is properly torn down
 	 */
 	if (priv->quirk->exit)
 		priv->quirk->exit(priv->dev);
 }
 EXPORT_SYMBOL_GPL(pciserial_suspend_ports);
 void pciserial_resume_ports(struct serial_private *priv)
 {
 	int i;
 	/*
 	 * Ensure that the board is correctly configured.
 	 */
 	if (priv->quirk->init)
 		priv->quirk->init(priv->dev);
 	for (i = 0; i < priv->nr; i++)
 		if (priv->line[i] >= 0)
 			serial8250_resume_port(priv->line[i]);
 }
 EXPORT_SYMBOL_GPL(pciserial_resume_ports);
 /*
  * Probe one serial board.  Unfortunately, there is no rhyme nor reason
  * to the arrangement of serial ports on a PCI card.
  */
 static int
 pciserial_init_one(struct pci_dev *dev, const struct pci_device_id *ent)
 {
 	struct pci_serial_quirk *quirk;
 	struct serial_private *priv;
 	const struct pciserial_board *board;
 	struct pciserial_board tmp;
 	int rc;
 	quirk = find_quirk(dev);
 	if (quirk->probe) {
 		rc = quirk->probe(dev);
 		if (rc)
 			return rc;
 	}
 	if (ent->driver_data >= ARRAY_SIZE(pci_boards)) {
 		dev_err(&dev->dev, "invalid driver_data: %ld\n",
 			ent->driver_data);
 		return -EINVAL;
 	}
 	board = &pci_boards[ent->driver_data];
 	rc = pci_enable_device(dev);
 	pci_save_state(dev);
 	if (rc)
 		return rc;
 	if (ent->driver_data == pbn_default) {
 		/*
 		 * Use a copy of the pci_board entry for this;
 		 * avoid changing entries in the table.
 		 */
 		memcpy(&tmp, board, sizeof(struct pciserial_board));
 		board = &tmp;
 		/*
 		 * We matched one of our class entries.  Try to
 		 * determine the parameters of this board.
 		 */
 		rc = serial_pci_guess_board(dev, &tmp);
 		if (rc)
 			goto disable;
 	} else {
 		/*
 		 * We matched an explicit entry.  If we are able to
 		 * detect this boards settings with our heuristic,
 		 * then we no longer need this entry.
 		 */
 		memcpy(&tmp, &pci_boards[pbn_default],
 		       sizeof(struct pciserial_board));
 		rc = serial_pci_guess_board(dev, &tmp);
 		if (rc == 0 && serial_pci_matches(board, &tmp))
 			moan_device("Redundant entry in serial pci_table.",
 				    dev);
 	}
 	priv = pciserial_init_ports(dev, board);
 	if (!IS_ERR(priv)) {
 		pci_set_drvdata(dev, priv);
 		return 0;
 	}
 	rc = PTR_ERR(priv);
  disable:
 	pci_disable_device(dev);
 	return rc;
 }
 static void pciserial_remove_one(struct pci_dev *dev)
 {
 	struct serial_private *priv = pci_get_drvdata(dev);
 	pciserial_remove_ports(priv);
 	pci_disable_device(dev);
 }
 #ifdef CONFIG_PM
 static int pciserial_suspend_one(struct pci_dev *dev, pm_message_t state)
 {
 	struct serial_private *priv = pci_get_drvdata(dev);
 	if (priv)
 		pciserial_suspend_ports(priv);
 	pci_save_state(dev);
 	pci_set_power_state(dev, pci_choose_state(dev, state));
 	return 0;
 }
 static int pciserial_resume_one(struct pci_dev *dev)
 {
 	int err;
 	struct serial_private *priv = pci_get_drvdata(dev);
 	pci_set_power_state(dev, PCI_D0);
 	pci_restore_state(dev);
 	if (priv) {
 		/*
 		 * The device may have been disabled.  Re-enable it.
 		 */
 		err = pci_enable_device(dev);
 		/* FIXME: We cannot simply error out here */
 		if (err)
 			dev_err(&dev->dev, "Unable to re-enable ports, trying to continue.\n");
 		pciserial_resume_ports(priv);
 	}
 	return 0;
 }
 #endif
 static struct pci_device_id serial_pci_tbl[] = {
 	/* Advantech use PCI_DEVICE_ID_ADVANTECH_PCI3620 (0x3620) as 'PCI_SUBVENDOR_ID' */
 	{	PCI_VENDOR_ID_ADVANTECH, PCI_DEVICE_ID_ADVANTECH_PCI3620,
 		PCI_DEVICE_ID_ADVANTECH_PCI3620, 0x0001, 0, 0,
 		pbn_b2_8_921600 },
 	/* Advantech also use 0x3618 and 0xf618 */
 	{	PCI_VENDOR_ID_ADVANTECH, PCI_DEVICE_ID_ADVANTECH_PCI3618,
 		PCI_DEVICE_ID_ADVANTECH_PCI3618, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_ADVANTECH, PCI_DEVICE_ID_ADVANTECH_PCIf618,
 		PCI_DEVICE_ID_ADVANTECH_PCI3618, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V960,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_232, 0, 0,
 		pbn_b1_8_1382400 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V960,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_232, 0, 0,
 		pbn_b1_4_1382400 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V960,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_232, 0, 0,
 		pbn_b1_2_1382400 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_232, 0, 0,
 		pbn_b1_8_1382400 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_232, 0, 0,
 		pbn_b1_4_1382400 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_232, 0, 0,
 		pbn_b1_2_1382400 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_485, 0, 0,
 		pbn_b1_8_921600 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_485_4_4, 0, 0,
 		pbn_b1_8_921600 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_485, 0, 0,
 		pbn_b1_4_921600 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH4_485_2_2, 0, 0,
 		pbn_b1_4_921600 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_485, 0, 0,
 		pbn_b1_2_921600 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH8_485_2_6, 0, 0,
 		pbn_b1_8_921600 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH081101V1, 0, 0,
 		pbn_b1_8_921600 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH041101V1, 0, 0,
 		pbn_b1_4_921600 },
 	{	PCI_VENDOR_ID_V3, PCI_DEVICE_ID_V3_V351,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_BH2_20MHZ, 0, 0,
 		pbn_b1_2_1250000 },
 	{	PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_TITAN_2, 0, 0,
 		pbn_b0_2_1843200 },
 	{	PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_TITAN_4, 0, 0,
 		pbn_b0_4_1843200 },
 	{	PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
 		PCI_VENDOR_ID_AFAVLAB,
 		PCI_SUBDEVICE_ID_AFAVLAB_P061, 0, 0,
 		pbn_b0_4_1152000 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C152,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_2_232, 0, 0,
 		pbn_b0_2_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C154,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_4_232, 0, 0,
 		pbn_b0_4_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C158,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_8_232, 0, 0,
 		pbn_b0_8_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C152,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_1_1, 0, 0,
 		pbn_b0_2_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C154,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_2_2, 0, 0,
 		pbn_b0_4_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C158,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_4_4, 0, 0,
 		pbn_b0_8_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C152,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_2, 0, 0,
 		pbn_b0_2_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C154,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_4, 0, 0,
 		pbn_b0_4_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C158,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_8, 0, 0,
 		pbn_b0_8_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C152,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_2_485, 0, 0,
 		pbn_b0_2_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C154,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_4_485, 0, 0,
 		pbn_b0_4_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C158,
 		PCI_SUBVENDOR_ID_CONNECT_TECH,
 		PCI_SUBDEVICE_ID_CONNECT_TECH_PCI_UART_8_485, 0, 0,
 		pbn_b0_8_1843200_200 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C152,
 		PCI_VENDOR_ID_IBM, PCI_SUBDEVICE_ID_IBM_SATURN_SERIAL_ONE_PORT,
 		0, 0, pbn_exar_ibm_saturn },
 	{	PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_U530,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_1_115200 },
 	{	PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_UCOMM2,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_2_115200 },
 	{	PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_UCOMM422,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_4_115200 },
 	{	PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_UCOMM232,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_2_115200 },
 	{	PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_COMM4,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_4_115200 },
 	{	PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_COMM8,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_8_115200 },
 	{	PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_7803,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_8_460800 },
 	{	PCI_VENDOR_ID_SEALEVEL, PCI_DEVICE_ID_SEALEVEL_UCOMM8,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_8_115200 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_GTEK_SERIAL2,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_2_115200 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_SPCOM200,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_2_921600 },
 	/*
 	 * VScom SPCOM800, from sl@s.pl
 	 */
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_SPCOM800,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_8_921600 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_1077,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_4_921600 },
 	/* Unknown card - subdevice 0x1584 */
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
 		PCI_VENDOR_ID_PLX,
 		PCI_SUBDEVICE_ID_UNKNOWN_0x1584, 0, 0,
 		pbn_b2_4_115200 },
 	/* Unknown card - subdevice 0x1588 */
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
 		PCI_VENDOR_ID_PLX,
 		PCI_SUBDEVICE_ID_UNKNOWN_0x1588, 0, 0,
 		pbn_b2_8_115200 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
 		PCI_SUBVENDOR_ID_KEYSPAN,
 		PCI_SUBDEVICE_ID_KEYSPAN_SX2, 0, 0,
 		pbn_panacom },
 	{	PCI_VENDOR_ID_PANACOM, PCI_DEVICE_ID_PANACOM_QUADMODEM,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_panacom4 },
 	{	PCI_VENDOR_ID_PANACOM, PCI_DEVICE_ID_PANACOM_DUALMODEM,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_panacom2 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
 		PCI_VENDOR_ID_ESDGMBH,
 		PCI_DEVICE_ID_ESDGMBH_CPCIASIO4, 0, 0,
 		pbn_b2_4_115200 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
 		PCI_SUBVENDOR_ID_CHASE_PCIFAST,
 		PCI_SUBDEVICE_ID_CHASE_PCIFAST4, 0, 0,
 		pbn_b2_4_460800 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
 		PCI_SUBVENDOR_ID_CHASE_PCIFAST,
 		PCI_SUBDEVICE_ID_CHASE_PCIFAST8, 0, 0,
 		pbn_b2_8_460800 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
 		PCI_SUBVENDOR_ID_CHASE_PCIFAST,
 		PCI_SUBDEVICE_ID_CHASE_PCIFAST16, 0, 0,
 		pbn_b2_16_460800 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
 		PCI_SUBVENDOR_ID_CHASE_PCIFAST,
 		PCI_SUBDEVICE_ID_CHASE_PCIFAST16FMC, 0, 0,
 		pbn_b2_16_460800 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
 		PCI_SUBVENDOR_ID_CHASE_PCIRAS,
 		PCI_SUBDEVICE_ID_CHASE_PCIRAS4, 0, 0,
 		pbn_b2_4_460800 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
 		PCI_SUBVENDOR_ID_CHASE_PCIRAS,
 		PCI_SUBDEVICE_ID_CHASE_PCIRAS8, 0, 0,
 		pbn_b2_8_460800 },
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9050,
 		PCI_SUBVENDOR_ID_EXSYS,
 		PCI_SUBDEVICE_ID_EXSYS_4055, 0, 0,
 		pbn_b2_4_115200 },
 	/*
 	 * Megawolf Romulus PCI Serial Card, from Mike Hudson
 	 * (Exoray@isys.ca)
 	 */
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_ROMULUS,
 		0x10b5, 0x106a, 0, 0,
 		pbn_plx_romulus },
 	/*
 	* EndRun Technologies. PCI express device range.
 	*    EndRun PTP/1588 has 2 Native UARTs.
 	*/
 	{	PCI_VENDOR_ID_ENDRUN, PCI_DEVICE_ID_ENDRUN_1588,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_endrun_2_4000000 },
 	/*
 	 * Quatech cards. These actually have configurable clocks but for
 	 * now we just use the default.
 	 *
 	 * 100 series are RS232, 200 series RS422,
 	 */
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSC100,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_4_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC100,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_2_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC100E,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_2_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC200,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_2_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSC200E,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_2_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSC200,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_4_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_ESC100D,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_8_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_ESC100M,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_8_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCP100,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_4_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCP100,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_2_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCP200,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_4_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCP200,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_2_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCLP100,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_4_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCLP100,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_2_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_SSCLP100,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_1_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_QSCLP200,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_4_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_DSCLP200,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_2_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_SSCLP200,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_1_115200 },
 	{	PCI_VENDOR_ID_QUATECH, PCI_DEVICE_ID_QUATECH_ESCLP100,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_8_115200 },
 	{	PCI_VENDOR_ID_SPECIALIX, PCI_DEVICE_ID_OXSEMI_16PCI954,
 		PCI_VENDOR_ID_SPECIALIX, PCI_SUBDEVICE_ID_SPECIALIX_SPEED4,
 		0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
 		PCI_SUBVENDOR_ID_SIIG, PCI_SUBDEVICE_ID_SIIG_QUARTET_SERIAL,
 		0, 0,
 		pbn_b0_4_1152000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0x9505,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_921600 },
 		/*
 		 * The below card is a little controversial since it is the
 		 * subject of a PCI vendor/device ID clash.  (See
 		 * www.ussg.iu.edu/hypermail/linux/kernel/0303.1/0516.html).
 		 * For now just used the hex ID 0x950a.
 		 */
 	{	PCI_VENDOR_ID_OXSEMI, 0x950a,
 		PCI_SUBVENDOR_ID_SIIG, PCI_SUBDEVICE_ID_SIIG_DUAL_00,
 		0, 0, pbn_b0_2_115200 },
 	{	PCI_VENDOR_ID_OXSEMI, 0x950a,
 		PCI_SUBVENDOR_ID_SIIG, PCI_SUBDEVICE_ID_SIIG_DUAL_30,
 		0, 0, pbn_b0_2_115200 },
 	{	PCI_VENDOR_ID_OXSEMI, 0x950a,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_2_1130000 },
 	{	PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_C950,
 		PCI_VENDOR_ID_OXSEMI, PCI_SUBDEVICE_ID_OXSEMI_C950, 0, 0,
 		pbn_b0_1_921600 },
 	{	PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI954,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_115200 },
 	{	PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI952,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_921600 },
 	{	PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI958,
 		PCI_ANY_ID , PCI_ANY_ID, 0, 0,
 		pbn_b2_8_1152000 },
 	/*
 	 * Oxford Semiconductor Inc. Tornado PCI express device range.
 	 */
 	{	PCI_VENDOR_ID_OXSEMI, 0xc101,    /* OXPCIe952 1 Legacy UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc105,    /* OXPCIe952 1 Legacy UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc11b,    /* OXPCIe952 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc11f,    /* OXPCIe952 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc120,    /* OXPCIe952 1 Legacy UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc124,    /* OXPCIe952 1 Legacy UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc138,    /* OXPCIe952 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc13d,    /* OXPCIe952 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc140,    /* OXPCIe952 1 Legacy UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc141,    /* OXPCIe952 1 Legacy UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc144,    /* OXPCIe952 1 Legacy UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc145,    /* OXPCIe952 1 Legacy UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc158,    /* OXPCIe952 2 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_2_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc15d,    /* OXPCIe952 2 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_2_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc208,    /* OXPCIe954 4 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_4_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc20d,    /* OXPCIe954 4 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_4_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc308,    /* OXPCIe958 8 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_8_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc30d,    /* OXPCIe958 8 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_8_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc40b,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc40f,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc41b,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc41f,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc42b,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc42f,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc43b,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc43f,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc44b,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc44f,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc45b,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc45f,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc46b,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc46f,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc47b,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc47f,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc48b,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc48f,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc49b,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc49f,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc4ab,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc4af,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc4bb,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc4bf,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc4cb,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_OXSEMI, 0xc4cf,    /* OXPCIe200 1 Native UART */
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	/*
 	 * Mainpine Inc. IQ Express "Rev3" utilizing OxSemi Tornado
 	 */
 	{	PCI_VENDOR_ID_MAINPINE, 0x4000,	/* IQ Express 1 Port V.34 Super-G3 Fax */
 		PCI_VENDOR_ID_MAINPINE, 0x4001, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_MAINPINE, 0x4000,	/* IQ Express 2 Port V.34 Super-G3 Fax */
 		PCI_VENDOR_ID_MAINPINE, 0x4002, 0, 0,
 		pbn_oxsemi_2_4000000 },
 	{	PCI_VENDOR_ID_MAINPINE, 0x4000,	/* IQ Express 4 Port V.34 Super-G3 Fax */
 		PCI_VENDOR_ID_MAINPINE, 0x4004, 0, 0,
 		pbn_oxsemi_4_4000000 },
 	{	PCI_VENDOR_ID_MAINPINE, 0x4000,	/* IQ Express 8 Port V.34 Super-G3 Fax */
 		PCI_VENDOR_ID_MAINPINE, 0x4008, 0, 0,
 		pbn_oxsemi_8_4000000 },
 	/*
 	 * Digi/IBM PCIe 2-port Async EIA-232 Adapter utilizing OxSemi Tornado
 	 */
 	{	PCI_VENDOR_ID_DIGI, PCIE_DEVICE_ID_NEO_2_OX_IBM,
 		PCI_SUBVENDOR_ID_IBM, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_2_4000000 },
 	/*
 	 * SBS Technologies, Inc. P-Octal and PMC-OCTPRO cards,
 	 * from skokodyn@yahoo.com
 	 */
 	{	PCI_VENDOR_ID_SBSMODULARIO, PCI_DEVICE_ID_OCTPRO,
 		PCI_SUBVENDOR_ID_SBSMODULARIO, PCI_SUBDEVICE_ID_OCTPRO232, 0, 0,
 		pbn_sbsxrsio },
 	{	PCI_VENDOR_ID_SBSMODULARIO, PCI_DEVICE_ID_OCTPRO,
 		PCI_SUBVENDOR_ID_SBSMODULARIO, PCI_SUBDEVICE_ID_OCTPRO422, 0, 0,
 		pbn_sbsxrsio },
 	{	PCI_VENDOR_ID_SBSMODULARIO, PCI_DEVICE_ID_OCTPRO,
 		PCI_SUBVENDOR_ID_SBSMODULARIO, PCI_SUBDEVICE_ID_POCTAL232, 0, 0,
 		pbn_sbsxrsio },
 	{	PCI_VENDOR_ID_SBSMODULARIO, PCI_DEVICE_ID_OCTPRO,
 		PCI_SUBVENDOR_ID_SBSMODULARIO, PCI_SUBDEVICE_ID_POCTAL422, 0, 0,
 		pbn_sbsxrsio },
 	/*
 	 * Digitan DS560-558, from jimd@esoft.com
 	 */
 	{	PCI_VENDOR_ID_ATT, PCI_DEVICE_ID_ATT_VENUS_MODEM,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_1_115200 },
 	/*
 	 * Titan Electronic cards
 	 *  The 400L and 800L have a custom setup quirk.
 	 */
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_100,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_2_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800B,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_100L,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_1_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200L,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_bt_2_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400L,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_4_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800L,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_8_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200I,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b4_bt_2_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400I,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b4_bt_4_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800I,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b4_bt_8_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400EH,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800EH,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800EHB,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_100E,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_1_4000000 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200E,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_2_4000000 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400E,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_4_4000000 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800E,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_8_4000000 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200EI,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_2_4000000 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200EISI,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi_2_4000000 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200V3,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400V3,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_410V3,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800V3,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800V3B,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_10x_550,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_1_460800 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_10x_650,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_1_460800 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_10x_850,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_1_460800 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_10x_550,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_2_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_10x_650,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_2_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_10x_850,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_2_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_10x_550,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_4_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_10x_650,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_4_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_10x_850,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_4_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_20x_550,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_20x_650,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_20x_850,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_20x_550,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_20x_650,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_20x_850,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_20x_550,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_4_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_20x_650,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_4_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_20x_850,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_4_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_8S_20x_550,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_8_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_8S_20x_650,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_8_921600 },
 	{	PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_8S_20x_850,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_8_921600 },
 	/*
 	 * Computone devices submitted by Doug McNash dmcnash@computone.com
 	 */
 	{	PCI_VENDOR_ID_COMPUTONE, PCI_DEVICE_ID_COMPUTONE_PG,
 		PCI_SUBVENDOR_ID_COMPUTONE, PCI_SUBDEVICE_ID_COMPUTONE_PG4,
 		0, 0, pbn_computone_4 },
 	{	PCI_VENDOR_ID_COMPUTONE, PCI_DEVICE_ID_COMPUTONE_PG,
 		PCI_SUBVENDOR_ID_COMPUTONE, PCI_SUBDEVICE_ID_COMPUTONE_PG8,
 		0, 0, pbn_computone_8 },
 	{	PCI_VENDOR_ID_COMPUTONE, PCI_DEVICE_ID_COMPUTONE_PG,
 		PCI_SUBVENDOR_ID_COMPUTONE, PCI_SUBDEVICE_ID_COMPUTONE_PG6,
 		0, 0, pbn_computone_6 },
 	{	PCI_VENDOR_ID_OXSEMI, PCI_DEVICE_ID_OXSEMI_16PCI95N,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_oxsemi },
 	{	PCI_VENDOR_ID_TIMEDIA, PCI_DEVICE_ID_TIMEDIA_1889,
 		PCI_VENDOR_ID_TIMEDIA, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_1_921600 },
 	/*
 	 * SUNIX (TIMEDIA)
 	 */
 	{	PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999,
 		PCI_VENDOR_ID_SUNIX, PCI_ANY_ID,
 		PCI_CLASS_COMMUNICATION_SERIAL << 8, 0xffff00,
 		pbn_b0_bt_1_921600 },
 	{	PCI_VENDOR_ID_SUNIX, PCI_DEVICE_ID_SUNIX_1999,
 		PCI_VENDOR_ID_SUNIX, PCI_ANY_ID,
 		PCI_CLASS_COMMUNICATION_MULTISERIAL << 8, 0xffff00,
 		pbn_b0_bt_1_921600 },
 	/*
 	 * AFAVLAB serial card, from Harald Welte <laforge@gnumonks.org>
 	 */
 	{	PCI_VENDOR_ID_AFAVLAB, PCI_DEVICE_ID_AFAVLAB_P028,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_8_115200 },
 	{	PCI_VENDOR_ID_AFAVLAB, PCI_DEVICE_ID_AFAVLAB_P030,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_8_115200 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_DSERIAL,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_115200 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUATRO_A,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_115200 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUATRO_B,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_115200 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUATTRO_A,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_115200 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUATTRO_B,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_115200 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_OCTO_A,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_4_460800 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_OCTO_B,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_4_460800 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_PORT_PLUS,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_460800 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUAD_A,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_460800 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_QUAD_B,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_2_460800 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_SSERIAL,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_1_115200 },
 	{	PCI_VENDOR_ID_LAVA, PCI_DEVICE_ID_LAVA_PORT_650,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_bt_1_460800 },
 	/*
 	 * Korenix Jetcard F0/F1 cards (JC1204, JC1208, JC1404, JC1408).
 	 * Cards are identified by their subsystem vendor IDs, which
 	 * (in hex) match the model number.
 	 *
 	 * Note that JC140x are RS422/485 cards which require ox950
 	 * ACR = 0x10, and as such are not currently fully supported.
 	 */
 	{	PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF0,
 		0x1204, 0x0004, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF0,
 		0x1208, 0x0004, 0, 0,
 		pbn_b0_4_921600 },
 /*	{	PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF0,
 		0x1402, 0x0002, 0, 0,
 		pbn_b0_2_921600 }, */
 /*	{	PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF0,
 		0x1404, 0x0004, 0, 0,
 		pbn_b0_4_921600 }, */
 	{	PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF1,
 		0x1208, 0x0004, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF2,
 		0x1204, 0x0004, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF2,
 		0x1208, 0x0004, 0, 0,
 		pbn_b0_4_921600 },
 	{	PCI_VENDOR_ID_KORENIX, PCI_DEVICE_ID_KORENIX_JETCARDF3,
 		0x1208, 0x0004, 0, 0,
 		pbn_b0_4_921600 },
 	/*
 	 * Dell Remote Access Card 4 - Tim_T_Murphy@Dell.com
 	 */
 	{	PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_RAC4,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_1_1382400 },
 	/*
 	 * Dell Remote Access Card III - Tim_T_Murphy@Dell.com
 	 */
 	{	PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_RACIII,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_1_1382400 },
 	/*
 	 * RAStel 2 port modem, gerg@moreton.com.au
 	 */
 	{	PCI_VENDOR_ID_MORETON, PCI_DEVICE_ID_RASTEL_2PORT,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_bt_2_115200 },
 	/*
 	 * EKF addition for i960 Boards form EKF with serial port
 	 */
 	{	PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_80960_RP,
 		0xE4BF, PCI_ANY_ID, 0, 0,
 		pbn_intel_i960 },
 	/*
 	 * Xircom Cardbus/Ethernet combos
 	 */
 	{	PCI_VENDOR_ID_XIRCOM, PCI_DEVICE_ID_XIRCOM_X3201_MDM,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_115200 },
 	/*
 	 * Xircom RBM56G cardbus modem - Dirk Arnold (temp entry)
 	 */
 	{	PCI_VENDOR_ID_XIRCOM, PCI_DEVICE_ID_XIRCOM_RBM56G,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_115200 },
 	/*
 	 * Untested PCI modems, sent in from various folks...
 	 */
 	/*
 	 * Elsa Model 56K PCI Modem, from Andreas Rath <arh@01019freenet.de>
 	 */
 	{	PCI_VENDOR_ID_ROCKWELL, 0x1004,
 		0x1048, 0x1500, 0, 0,
 		pbn_b1_1_115200 },
 	{	PCI_VENDOR_ID_SGI, PCI_DEVICE_ID_SGI_IOC3,
 		0xFF00, 0, 0, 0,
 		pbn_sgi_ioc3 },
 	/*
 	 * HP Diva card
 	 */
 	{	PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_DIVA,
 		PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_DIVA_RMP3, 0, 0,
 		pbn_b1_1_115200 },
 	{	PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_DIVA,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_5_115200 },
 	{	PCI_VENDOR_ID_HP, PCI_DEVICE_ID_HP_DIVA_AUX,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b2_1_115200 },
 	{	PCI_VENDOR_ID_DCI, PCI_DEVICE_ID_DCI_PCCOM2,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b3_2_115200 },
 	{	PCI_VENDOR_ID_DCI, PCI_DEVICE_ID_DCI_PCCOM4,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b3_4_115200 },
 	{	PCI_VENDOR_ID_DCI, PCI_DEVICE_ID_DCI_PCCOM8,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b3_8_115200 },
 	/*
 	 * Exar Corp. XR17C15[248] Dual/Quad/Octal UART
 	 */
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C152,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_exar_XR17C152 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C154,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_exar_XR17C154 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17C158,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_exar_XR17C158 },
 	/*
 	 * Exar Corp. XR17V35[248] Dual/Quad/Octal PCIe UARTs
 	 */
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17V352,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_exar_XR17V352 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17V354,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_exar_XR17V354 },
 	{	PCI_VENDOR_ID_EXAR, PCI_DEVICE_ID_EXAR_XR17V358,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_exar_XR17V358 },
 	/*
 	 * Topic TP560 Data/Fax/Voice 56k modem (reported by Evan Clarke)
 	 */
 	{	PCI_VENDOR_ID_TOPIC, PCI_DEVICE_ID_TOPIC_TP560,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b0_1_115200 },
 	/*
 	 * ITE
 	 */
 	{	PCI_VENDOR_ID_ITE, PCI_DEVICE_ID_ITE_8872,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0, 0,
 		pbn_b1_bt_1_115200 },
 	/*
 	 * IntaShield IS-200
 	 */
 	{	PCI_VENDOR_ID_INTASHIELD, PCI_DEVICE_ID_INTASHIELD_IS200,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,	/* 135a.0811 */
 		pbn_b2_2_115200 },
 	/*
 	 * IntaShield IS-400
 	 */
 	{	PCI_VENDOR_ID_INTASHIELD, PCI_DEVICE_ID_INTASHIELD_IS400,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,    /* 135a.0dc0 */
 		pbn_b2_4_115200 },
 	/*
 	 * Perle PCI-RAS cards
 	 */
 	{       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
 		PCI_SUBVENDOR_ID_PERLE, PCI_SUBDEVICE_ID_PCI_RAS4,
 		0, 0, pbn_b2_4_921600 },
 	{       PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_9030,
 		PCI_SUBVENDOR_ID_PERLE, PCI_SUBDEVICE_ID_PCI_RAS8,
 		0, 0, pbn_b2_8_921600 },
 	/*
 	 * Mainpine series cards: Fairly standard layout but fools
 	 * parts of the autodetect in some cases and uses otherwise
 	 * unmatched communications subclasses in the PCI Express case
 	 */
 	{	/* RockForceDUO */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x0200,
 		0, 0, pbn_b0_2_115200 },
 	{	/* RockForceQUATRO */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x0300,
 		0, 0, pbn_b0_4_115200 },
 	{	/* RockForceDUO+ */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x0400,
 		0, 0, pbn_b0_2_115200 },
 	{	/* RockForceQUATRO+ */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x0500,
 		0, 0, pbn_b0_4_115200 },
 	{	/* RockForce+ */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x0600,
 		0, 0, pbn_b0_2_115200 },
 	{	/* RockForce+ */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x0700,
 		0, 0, pbn_b0_4_115200 },
 	{	/* RockForceOCTO+ */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x0800,
 		0, 0, pbn_b0_8_115200 },
 	{	/* RockForceDUO+ */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x0C00,
 		0, 0, pbn_b0_2_115200 },
 	{	/* RockForceQUARTRO+ */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x0D00,
 		0, 0, pbn_b0_4_115200 },
 	{	/* RockForceOCTO+ */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x1D00,
 		0, 0, pbn_b0_8_115200 },
 	{	/* RockForceD1 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x2000,
 		0, 0, pbn_b0_1_115200 },
 	{	/* RockForceF1 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x2100,
 		0, 0, pbn_b0_1_115200 },
 	{	/* RockForceD2 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x2200,
 		0, 0, pbn_b0_2_115200 },
 	{	/* RockForceF2 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x2300,
 		0, 0, pbn_b0_2_115200 },
 	{	/* RockForceD4 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x2400,
 		0, 0, pbn_b0_4_115200 },
 	{	/* RockForceF4 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x2500,
 		0, 0, pbn_b0_4_115200 },
 	{	/* RockForceD8 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x2600,
 		0, 0, pbn_b0_8_115200 },
 	{	/* RockForceF8 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x2700,
 		0, 0, pbn_b0_8_115200 },
 	{	/* IQ Express D1 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x3000,
 		0, 0, pbn_b0_1_115200 },
 	{	/* IQ Express F1 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x3100,
 		0, 0, pbn_b0_1_115200 },
 	{	/* IQ Express D2 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x3200,
 		0, 0, pbn_b0_2_115200 },
 	{	/* IQ Express F2 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x3300,
 		0, 0, pbn_b0_2_115200 },
 	{	/* IQ Express D4 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x3400,
 		0, 0, pbn_b0_4_115200 },
 	{	/* IQ Express F4 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x3500,
 		0, 0, pbn_b0_4_115200 },
 	{	/* IQ Express D8 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x3C00,
 		0, 0, pbn_b0_8_115200 },
 	{	/* IQ Express F8 */
 		PCI_VENDOR_ID_MAINPINE, PCI_DEVICE_ID_MAINPINE_PBRIDGE,
 		PCI_VENDOR_ID_MAINPINE, 0x3D00,
 		0, 0, pbn_b0_8_115200 },
 	/*
 	 * PA Semi PA6T-1682M on-chip UART
 	 */
 	{	PCI_VENDOR_ID_PASEMI, 0xa004,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_pasemi_1682M },
 	/*
 	 * National Instruments
 	 */
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI23216,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_16_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI2328,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_8_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI2324,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_bt_4_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI2322,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_bt_2_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI2324I,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_bt_4_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI2322I,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_bt_2_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8420_23216,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_16_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8420_2328,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_8_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8420_2324,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_bt_4_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8420_2322,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_bt_2_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8422_2324,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_bt_4_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8422_2322,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_b1_bt_2_115200 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8430_2322,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_2 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8430_2322,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_2 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8430_2324,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_4 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8430_2324,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_4 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8430_2328,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_8 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8430_2328,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_8 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8430_23216,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_16 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8430_23216,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_16 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8432_2322,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_2 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8432_2322,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_2 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PXI8432_2324,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_4 },
 	{	PCI_VENDOR_ID_NI, PCI_DEVICE_ID_NI_PCI8432_2324,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_ni8430_4 },
 	/*
 	* ADDI-DATA GmbH communication cards <info@addi-data.com>
 	*/
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCI7500,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_b0_4_115200 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCI7420,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_b0_2_115200 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCI7300,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_b0_1_115200 },
 	{	PCI_VENDOR_ID_AMCC,
 		PCI_DEVICE_ID_AMCC_ADDIDATA_APCI7800,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_b1_8_115200 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCI7500_2,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_b0_4_115200 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCI7420_2,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_b0_2_115200 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCI7300_2,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_b0_1_115200 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCI7500_3,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_b0_4_115200 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCI7420_3,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_b0_2_115200 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCI7300_3,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_b0_1_115200 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCI7800_3,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_b0_8_115200 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCIe7500,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_ADDIDATA_PCIe_4_3906250 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCIe7420,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_ADDIDATA_PCIe_2_3906250 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCIe7300,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_ADDIDATA_PCIe_1_3906250 },
 	{	PCI_VENDOR_ID_ADDIDATA,
 		PCI_DEVICE_ID_ADDIDATA_APCIe7800,
 		PCI_ANY_ID,
 		PCI_ANY_ID,
 		0,
 		0,
 		pbn_ADDIDATA_PCIe_8_3906250 },
 	{	PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9835,
 		PCI_VENDOR_ID_IBM, 0x0299,
 		0, 0, pbn_b0_bt_2_115200 },
 	/*
 	 * other NetMos 9835 devices are most likely handled by the
 	 * parport_serial driver, check drivers/parport/parport_serial.c
 	 * before adding them here.
 	 */
 	{	PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9901,
 		0xA000, 0x1000,
 		0, 0, pbn_b0_1_115200 },
 	/* the 9901 is a rebranded 9912 */
 	{	PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9912,
 		0xA000, 0x1000,
 		0, 0, pbn_b0_1_115200 },
 	{	PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9922,
 		0xA000, 0x1000,
 		0, 0, pbn_b0_1_115200 },
 	{	PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9904,
 		0xA000, 0x1000,
 		0, 0, pbn_b0_1_115200 },
 	{	PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9900,
 		0xA000, 0x1000,
 		0, 0, pbn_b0_1_115200 },
 	{	PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9900,
 		0xA000, 0x3002,
 		0, 0, pbn_NETMOS9900_2s_115200 },
 	/*
 	 * Best Connectivity and Rosewill PCI Multi I/O cards
 	 */
 	{	PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
 		0xA000, 0x1000,
 		0, 0, pbn_b0_1_115200 },
 	{	PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
 		0xA000, 0x3002,
 		0, 0, pbn_b0_bt_2_115200 },
 	{	PCI_VENDOR_ID_NETMOS, PCI_DEVICE_ID_NETMOS_9865,
 		0xA000, 0x3004,
 		0, 0, pbn_b0_bt_4_115200 },
 	/* Intel CE4100 */
 	{	PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_CE4100_UART,
 		PCI_ANY_ID,  PCI_ANY_ID, 0, 0,
 		pbn_ce4100_1_115200 },
 	/* Intel BayTrail */
 	{	PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BYT_UART1,
 		PCI_ANY_ID,  PCI_ANY_ID,
 		PCI_CLASS_COMMUNICATION_SERIAL << 8, 0xff0000,
 		pbn_byt },
 	{	PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BYT_UART2,
 		PCI_ANY_ID,  PCI_ANY_ID,
 		PCI_CLASS_COMMUNICATION_SERIAL << 8, 0xff0000,
 		pbn_byt },
 	{	PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BSW_UART1,
 		PCI_ANY_ID,  PCI_ANY_ID,
 		PCI_CLASS_COMMUNICATION_SERIAL << 8, 0xff0000,
 		pbn_byt },
 	{	PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BSW_UART2,
 		PCI_ANY_ID,  PCI_ANY_ID,
 		PCI_CLASS_COMMUNICATION_SERIAL << 8, 0xff0000,
 		pbn_byt },
 	/*
 	 * Intel Quark x1000
 	 */
 	{	PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_QRK_UART,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_qrk },
 	/*
 	 * Cronyx Omega PCI
 	 */
 	{	PCI_VENDOR_ID_PLX, PCI_DEVICE_ID_PLX_CRONYX_OMEGA,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_omegapci },
 	/*
 	 * Broadcom TruManage
 	 */
 	{	PCI_VENDOR_ID_BROADCOM, PCI_DEVICE_ID_BROADCOM_TRUMANAGE,
 		PCI_ANY_ID, PCI_ANY_ID, 0, 0,
 		pbn_brcm_trumanage },
 	/*
 	 * AgeStar as-prs2-009
 	 */
 	{	PCI_VENDOR_ID_AGESTAR, PCI_DEVICE_ID_AGESTAR_9375,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0, 0, pbn_b0_bt_2_115200 },
 	/*
 	 * WCH CH353 series devices: The 2S1P is handled by parport_serial
 	 * so not listed here.
 	 */
 	{	PCI_VENDOR_ID_WCH, PCI_DEVICE_ID_WCH_CH353_4S,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0, 0, pbn_b0_bt_4_115200 },
 	{	PCI_VENDOR_ID_WCH, PCI_DEVICE_ID_WCH_CH353_2S1PF,
-		PCI_ANY_ID, PCI_ANY_ID,
-		0, 0, pbn_b0_bt_2_115200 },
-	{	PCI_VENDOR_ID_WCH, PCI_DEVICE_ID_WCH_CH352_2S,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0, 0, pbn_b0_bt_2_115200 },
 	{	PCIE_VENDOR_ID_WCH, PCIE_DEVICE_ID_WCH_CH384_4S,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0, 0, pbn_wch384_4 },
 	/*
 	 * Commtech, Inc. Fastcom adapters
 	 */
 	{	PCI_VENDOR_ID_COMMTECH, PCI_DEVICE_ID_COMMTECH_4222PCI335,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_b0_2_1152000_200 },
 	{	PCI_VENDOR_ID_COMMTECH, PCI_DEVICE_ID_COMMTECH_4224PCI335,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_b0_4_1152000_200 },
 	{	PCI_VENDOR_ID_COMMTECH, PCI_DEVICE_ID_COMMTECH_2324PCI335,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_b0_4_1152000_200 },
 	{	PCI_VENDOR_ID_COMMTECH, PCI_DEVICE_ID_COMMTECH_2328PCI335,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_b0_8_1152000_200 },
 	{	PCI_VENDOR_ID_COMMTECH, PCI_DEVICE_ID_COMMTECH_4222PCIE,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_exar_XR17V352 },
 	{	PCI_VENDOR_ID_COMMTECH, PCI_DEVICE_ID_COMMTECH_4224PCIE,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_exar_XR17V354 },
 	{	PCI_VENDOR_ID_COMMTECH, PCI_DEVICE_ID_COMMTECH_4228PCIE,
 		PCI_ANY_ID, PCI_ANY_ID,
 		0,
 		0, pbn_exar_XR17V358 },
 	/* Fintek PCI serial cards */
 	{ PCI_DEVICE(0x1c29, 0x1104), .driver_data = pbn_fintek_4 },
 	{ PCI_DEVICE(0x1c29, 0x1108), .driver_data = pbn_fintek_8 },
 	{ PCI_DEVICE(0x1c29, 0x1112), .driver_data = pbn_fintek_12 },
 	/*
 	 * These entries match devices with class COMMUNICATION_SERIAL,
 	 * COMMUNICATION_MODEM or COMMUNICATION_MULTISERIAL
 	 */
 	{	PCI_ANY_ID, PCI_ANY_ID,
 		PCI_ANY_ID, PCI_ANY_ID,
 		PCI_CLASS_COMMUNICATION_SERIAL << 8,
 		0xffff00, pbn_default },
 	{	PCI_ANY_ID, PCI_ANY_ID,
 		PCI_ANY_ID, PCI_ANY_ID,
 		PCI_CLASS_COMMUNICATION_MODEM << 8,
 		0xffff00, pbn_default },
 	{	PCI_ANY_ID, PCI_ANY_ID,
 		PCI_ANY_ID, PCI_ANY_ID,
 		PCI_CLASS_COMMUNICATION_MULTISERIAL << 8,
 		0xffff00, pbn_default },
 	{ 0, }
 };
 static pci_ers_result_t serial8250_io_error_detected(struct pci_dev *dev,
 						pci_channel_state_t state)
 {
 	struct serial_private *priv = pci_get_drvdata(dev);
 	if (state == pci_channel_io_perm_failure)
 		return PCI_ERS_RESULT_DISCONNECT;
 	if (priv)
 		pciserial_suspend_ports(priv);
 	pci_disable_device(dev);
 	return PCI_ERS_RESULT_NEED_RESET;
 }
 static pci_ers_result_t serial8250_io_slot_reset(struct pci_dev *dev)
 {
 	int rc;
 	rc = pci_enable_device(dev);
 	if (rc)
 		return PCI_ERS_RESULT_DISCONNECT;
 	pci_restore_state(dev);
 	pci_save_state(dev);
 	return PCI_ERS_RESULT_RECOVERED;
 }
 static void serial8250_io_resume(struct pci_dev *dev)
 {
 	struct serial_private *priv = pci_get_drvdata(dev);
 	if (priv)
 		pciserial_resume_ports(priv);
 }
 static const struct pci_error_handlers serial8250_err_handler = {
 	.error_detected = serial8250_io_error_detected,
 	.slot_reset = serial8250_io_slot_reset,
 	.resume = serial8250_io_resume,
 };
 static struct pci_driver serial_pci_driver = {
 	.name		= "serial",
 	.probe		= pciserial_init_one,
 	.remove		= pciserial_remove_one,
 #ifdef CONFIG_PM
 	.suspend	= pciserial_suspend_one,
 	.resume		= pciserial_resume_one,
 #endif
 	.id_table	= serial_pci_tbl,
 	.err_handler	= &serial8250_err_handler,
 };
 module_pci_driver(serial_pci_driver);
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Generic 8250/16x50 PCI serial probe module");
 MODULE_DEVICE_TABLE(pci, serial_pci_tbl);

drivers/tty/serial/of_serial.c

Diff comments View file @ bbbce51

 /*
  *  Serial Port driver for Open Firmware platform devices
  *
  *    Copyright (C) 2006 Arnd Bergmann <arnd@arndb.de>, IBM Corp.
  *
  *  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.
  *
  */
 #include <linux/console.h>
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/serial_core.h>
 #include <linux/serial_reg.h>
 #include <linux/of_address.h>
 #include <linux/of_irq.h>
 #include <linux/of_platform.h>
 #include <linux/nwpserial.h>
 #include <linux/clk.h>
 #include "8250/8250.h"
 struct of_serial_info {
 	struct clk *clk;
 	int type;
 	int line;
 };
 #ifdef CONFIG_ARCH_TEGRA
 void tegra_serial_handle_break(struct uart_port *p)
 {
 	unsigned int status, tmout = 10000;
 	do {
 		status = p->serial_in(p, UART_LSR);
 		if (status & (UART_LSR_FIFOE | UART_LSR_BRK_ERROR_BITS))
 			status = p->serial_in(p, UART_RX);
 		else
 			break;
 		if (--tmout == 0)
 			break;
 		udelay(1);
 	} while (1);
 }
 #else
 static inline void tegra_serial_handle_break(struct uart_port *port)
 {
 }
 #endif
 /*
  * Fill a struct uart_port for a given device node
  */
 static int of_platform_serial_setup(struct platform_device *ofdev,
 			int type, struct uart_port *port,
 			struct of_serial_info *info)
 {
 	struct resource resource;
 	struct device_node *np = ofdev->dev.of_node;
 	u32 clk, spd, prop;
 	int ret;
 	memset(port, 0, sizeof *port);
 	if (of_property_read_u32(np, "clock-frequency", &clk)) {
 		/* Get clk rate through clk driver if present */
 		info->clk = clk_get(&ofdev->dev, NULL);
 		if (IS_ERR(info->clk)) {
 			dev_warn(&ofdev->dev,
 				"clk or clock-frequency not defined\n");
 			return PTR_ERR(info->clk);
 		}
 		clk_prepare_enable(info->clk);
 		clk = clk_get_rate(info->clk);
 	}
 	/* If current-speed was set, then try not to change it. */
 	if (of_property_read_u32(np, "current-speed", &spd) == 0)
 		port->custom_divisor = clk / (16 * spd);
 	ret = of_address_to_resource(np, 0, &resource);
 	if (ret) {
 		dev_warn(&ofdev->dev, "invalid address\n");
 		goto out;
 	}
 	spin_lock_init(&port->lock);
 	port->mapbase = resource.start;
 	/* Check for shifted address mapping */
 	if (of_property_read_u32(np, "reg-offset", &prop) == 0)
 		port->mapbase += prop;
 	/* Check for registers offset within the devices address range */
 	if (of_property_read_u32(np, "reg-shift", &prop) == 0)
 		port->regshift = prop;
 	/* Check for fifo size */
 	if (of_property_read_u32(np, "fifo-size", &prop) == 0)
 		port->fifosize = prop;
 	/* Check for a fixed line number */
 	ret = of_alias_get_id(np, "serial");
 	if (ret >= 0)
 		port->line = ret;
 	port->irq = irq_of_parse_and_map(np, 0);
 	port->iotype = UPIO_MEM;
 	if (of_property_read_u32(np, "reg-io-width", &prop) == 0) {
 		switch (prop) {
 		case 1:
 			port->iotype = UPIO_MEM;
 			break;
 		case 4:
 			port->iotype = UPIO_MEM32;
 			break;
 		default:
 			dev_warn(&ofdev->dev, "unsupported reg-io-width (%d)\n",
 				 prop);
 			ret = -EINVAL;
 			goto out;
 		}
 	}
 	port->type = type;
 	port->uartclk = clk;
 	port->flags = UPF_SHARE_IRQ | UPF_BOOT_AUTOCONF | UPF_IOREMAP
 		| UPF_FIXED_PORT | UPF_FIXED_TYPE;
 	if (of_find_property(np, "no-loopback-test", NULL))
 		port->flags |= UPF_SKIP_TEST;
-	ret = of_alias_get_id(np, "serial");
-	if (ret >= 0)
-		port->line = ret;
 	port->dev = &ofdev->dev;
 	switch (type) {
 	case PORT_TEGRA:
 		port->handle_break = tegra_serial_handle_break;
 		break;
 	case PORT_RT2880:
 		port->iotype = UPIO_AU;
 		break;
 	}
 	return 0;
 out:
 	if (info->clk)
 		clk_disable_unprepare(info->clk);
 	return ret;
 }
 /*
  * Try to register a serial port
  */
 static struct of_device_id of_platform_serial_table[];
 static int of_platform_serial_probe(struct platform_device *ofdev)
 {
 	const struct of_device_id *match;
 	struct of_serial_info *info;
 	struct uart_port port;
 	int port_type;
 	int ret;
 	match = of_match_device(of_platform_serial_table, &ofdev->dev);
 	if (!match)
 		return -EINVAL;
 	if (of_find_property(ofdev->dev.of_node, "used-by-rtas", NULL))
 		return -EBUSY;
 	info = kzalloc(sizeof(*info), GFP_KERNEL);
 	if (info == NULL)
 		return -ENOMEM;
 	port_type = (unsigned long)match->data;
 	ret = of_platform_serial_setup(ofdev, port_type, &port, info);
 	if (ret)
 		goto out;
 	switch (port_type) {
 #ifdef CONFIG_SERIAL_8250
 	case PORT_8250 ... PORT_MAX_8250:
 	{
 		struct uart_8250_port port8250;
 		memset(&port8250, 0, sizeof(port8250));
 		port.type = port_type;
 		port8250.port = port;
 		if (port.fifosize)
 			port8250.capabilities = UART_CAP_FIFO;
 		if (of_property_read_bool(ofdev->dev.of_node,
 					  "auto-flow-control"))
 			port8250.capabilities |= UART_CAP_AFE;
 		ret = serial8250_register_8250_port(&port8250);
 		break;
 	}
 #endif
 #ifdef CONFIG_SERIAL_OF_PLATFORM_NWPSERIAL
 	case PORT_NWPSERIAL:
 		ret = nwpserial_register_port(&port);
 		break;
 #endif
 	default:
 		/* need to add code for these */
 	case PORT_UNKNOWN:
 		dev_info(&ofdev->dev, "Unknown serial port found, ignored\n");
 		ret = -ENODEV;
 		break;
 	}
 	if (ret < 0)
 		goto out;
 	info->type = port_type;
 	info->line = ret;
 	platform_set_drvdata(ofdev, info);
 	return 0;
 out:
 	kfree(info);
 	irq_dispose_mapping(port.irq);
 	return ret;
 }
 /*
  * Release a line
  */
 static int of_platform_serial_remove(struct platform_device *ofdev)
 {
 	struct of_serial_info *info = platform_get_drvdata(ofdev);
 	switch (info->type) {
 #ifdef CONFIG_SERIAL_8250
 	case PORT_8250 ... PORT_MAX_8250:
 		serial8250_unregister_port(info->line);
 		break;
 #endif
 #ifdef CONFIG_SERIAL_OF_PLATFORM_NWPSERIAL
 	case PORT_NWPSERIAL:
 		nwpserial_unregister_port(info->line);
 		break;
 #endif
 	default:
 		/* need to add code for these */
 		break;
 	}
 	if (info->clk)
 		clk_disable_unprepare(info->clk);
 	kfree(info);
 	return 0;
 }
 #ifdef CONFIG_PM_SLEEP
 #ifdef CONFIG_SERIAL_8250
 static void of_serial_suspend_8250(struct of_serial_info *info)
 {
 	struct uart_8250_port *port8250 = serial8250_get_port(info->line);
 	struct uart_port *port = &port8250->port;
 	serial8250_suspend_port(info->line);
 	if (info->clk && (!uart_console(port) || console_suspend_enabled))
 		clk_disable_unprepare(info->clk);
 }
 static void of_serial_resume_8250(struct of_serial_info *info)
 {
 	struct uart_8250_port *port8250 = serial8250_get_port(info->line);
 	struct uart_port *port = &port8250->port;
 	if (info->clk && (!uart_console(port) || console_suspend_enabled))
 		clk_prepare_enable(info->clk);
 	serial8250_resume_port(info->line);
 }
 #else
 static inline void of_serial_suspend_8250(struct of_serial_info *info)
 {
 }
 static inline void of_serial_resume_8250(struct of_serial_info *info)
 {
 }
 #endif
 static int of_serial_suspend(struct device *dev)
 {
 	struct of_serial_info *info = dev_get_drvdata(dev);
 	switch (info->type) {
 	case PORT_8250 ... PORT_MAX_8250:
 		of_serial_suspend_8250(info);
 		break;
 	default:
 		break;
 	}
 	return 0;
 }
 static int of_serial_resume(struct device *dev)
 {
 	struct of_serial_info *info = dev_get_drvdata(dev);
 	switch (info->type) {
 	case PORT_8250 ... PORT_MAX_8250:
 		of_serial_resume_8250(info);
 		break;
 	default:
 		break;
 	}
 	return 0;
 }
 #endif
 static SIMPLE_DEV_PM_OPS(of_serial_pm_ops, of_serial_suspend, of_serial_resume);
 /*
  * A few common types, add more as needed.
  */
 static struct of_device_id of_platform_serial_table[] = {
 	{ .compatible = "ns8250",   .data = (void *)PORT_8250, },
 	{ .compatible = "ns16450",  .data = (void *)PORT_16450, },
 	{ .compatible = "ns16550a", .data = (void *)PORT_16550A, },
 	{ .compatible = "ns16550",  .data = (void *)PORT_16550, },
 	{ .compatible = "ns16750",  .data = (void *)PORT_16750, },
 	{ .compatible = "ns16850",  .data = (void *)PORT_16850, },
 	{ .compatible = "nvidia,tegra20-uart", .data = (void *)PORT_TEGRA, },
 	{ .compatible = "nxp,lpc3220-uart", .data = (void *)PORT_LPC3220, },
 	{ .compatible = "ralink,rt2880-uart", .data = (void *)PORT_RT2880, },
 	{ .compatible = "altr,16550-FIFO32",
 		.data = (void *)PORT_ALTR_16550_F32, },
 	{ .compatible = "altr,16550-FIFO64",
 		.data = (void *)PORT_ALTR_16550_F64, },
 	{ .compatible = "altr,16550-FIFO128",
 		.data = (void *)PORT_ALTR_16550_F128, },
 	{ .compatible = "mrvl,mmp-uart",
 		.data = (void *)PORT_XSCALE, },
 	{ .compatible = "mrvl,pxa-uart",
 		.data = (void *)PORT_XSCALE, },
 #ifdef CONFIG_SERIAL_OF_PLATFORM_NWPSERIAL
 	{ .compatible = "ibm,qpace-nwp-serial",
 		.data = (void *)PORT_NWPSERIAL, },
 #endif
 	{ .type = "serial",         .data = (void *)PORT_UNKNOWN, },
 	{ /* end of list */ },
 };
 static struct platform_driver of_platform_serial_driver = {
 	.driver = {
 		.name = "of_serial",
 		.of_match_table = of_platform_serial_table,
 	},
 	.probe = of_platform_serial_probe,
 	.remove = of_platform_serial_remove,
 };
 module_platform_driver(of_platform_serial_driver);
 MODULE_AUTHOR("Arnd Bergmann <arnd@arndb.de>");
 MODULE_LICENSE("GPL");
 MODULE_DESCRIPTION("Serial Port driver for Open Firmware platform devices");

drivers/tty/serial/sprd_serial.c

Diff comments View file @ bbbce51

 /*
  * Copyright (C) 2012-2015 Spreadtrum Communications Inc.
  *
  * This software is licensed under the terms of the GNU General Public
  * License version 2, as published by the Free Software Foundation, and
  * may be copied, distributed, and modified under those terms.
  *
  * 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.
  */
 #if defined(CONFIG_SERIAL_SPRD_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
 #define SUPPORT_SYSRQ
 #endif
 #include <linux/clk.h>
 #include <linux/console.h>
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/ioport.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/serial_core.h>
 #include <linux/serial.h>
 #include <linux/slab.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 /* device name */
 #define UART_NR_MAX		8
 #define SPRD_TTY_NAME		"ttyS"
 #define SPRD_FIFO_SIZE		128
 #define SPRD_DEF_RATE		26000000
 #define SPRD_BAUD_IO_LIMIT	3000000
 #define SPRD_TIMEOUT		256
 /* the offset of serial registers and BITs for them */
 /* data registers */
 #define SPRD_TXD		0x0000
 #define SPRD_RXD		0x0004
 /* line status register and its BITs  */
 #define SPRD_LSR		0x0008
 #define SPRD_LSR_OE		BIT(4)
 #define SPRD_LSR_FE		BIT(3)
 #define SPRD_LSR_PE		BIT(2)
 #define SPRD_LSR_BI		BIT(7)
 #define SPRD_LSR_TX_OVER	BIT(15)
 /* data number in TX and RX fifo */
 #define SPRD_STS1		0x000C
 /* interrupt enable register and its BITs */
 #define SPRD_IEN		0x0010
 #define SPRD_IEN_RX_FULL	BIT(0)
 #define SPRD_IEN_TX_EMPTY	BIT(1)
 #define SPRD_IEN_BREAK_DETECT	BIT(7)
 #define SPRD_IEN_TIMEOUT	BIT(13)
 /* interrupt clear register */
 #define SPRD_ICLR		0x0014
 /* line control register */
 #define SPRD_LCR		0x0018
 #define SPRD_LCR_STOP_1BIT	0x10
 #define SPRD_LCR_STOP_2BIT	0x30
 #define SPRD_LCR_DATA_LEN	(BIT(2) | BIT(3))
 #define SPRD_LCR_DATA_LEN5	0x0
 #define SPRD_LCR_DATA_LEN6	0x4
 #define SPRD_LCR_DATA_LEN7	0x8
 #define SPRD_LCR_DATA_LEN8	0xc
 #define SPRD_LCR_PARITY	(BIT(0) | BIT(1))
 #define SPRD_LCR_PARITY_EN	0x2
 #define SPRD_LCR_EVEN_PAR	0x0
 #define SPRD_LCR_ODD_PAR	0x1
 /* control register 1 */
 #define SPRD_CTL1			0x001C
 #define RX_HW_FLOW_CTL_THLD	BIT(6)
 #define RX_HW_FLOW_CTL_EN	BIT(7)
 #define TX_HW_FLOW_CTL_EN	BIT(8)
 #define RX_TOUT_THLD_DEF	0x3E00
 #define RX_HFC_THLD_DEF	0x40
 /* fifo threshold register */
 #define SPRD_CTL2		0x0020
 #define THLD_TX_EMPTY	0x40
 #define THLD_RX_FULL	0x40
 /* config baud rate register */
 #define SPRD_CLKD0		0x0024
 #define SPRD_CLKD1		0x0028
 /* interrupt mask status register */
 #define SPRD_IMSR			0x002C
 #define SPRD_IMSR_RX_FIFO_FULL		BIT(0)
 #define SPRD_IMSR_TX_FIFO_EMPTY	BIT(1)
 #define SPRD_IMSR_BREAK_DETECT		BIT(7)
 #define SPRD_IMSR_TIMEOUT		BIT(13)
 struct reg_backup {
 	u32 ien;
 	u32 ctrl0;
 	u32 ctrl1;
 	u32 ctrl2;
 	u32 clkd0;
 	u32 clkd1;
 	u32 dspwait;
 };
 struct sprd_uart_port {
 	struct uart_port port;
 	struct reg_backup reg_bak;
 	char name[16];
 };
 static struct sprd_uart_port *sprd_port[UART_NR_MAX];
 static int sprd_ports_num;
 static inline unsigned int serial_in(struct uart_port *port, int offset)
 {
 	return readl_relaxed(port->membase + offset);
 }
 static inline void serial_out(struct uart_port *port, int offset, int value)
 {
 	writel_relaxed(value, port->membase + offset);
 }
 static unsigned int sprd_tx_empty(struct uart_port *port)
 {
 	if (serial_in(port, SPRD_STS1) & 0xff00)
 		return 0;
 	else
 		return TIOCSER_TEMT;
 }
 static unsigned int sprd_get_mctrl(struct uart_port *port)
 {
 	return TIOCM_DSR | TIOCM_CTS;
 }
 static void sprd_set_mctrl(struct uart_port *port, unsigned int mctrl)
 {
 	/* nothing to do */
 }
 static void sprd_stop_tx(struct uart_port *port)
 {
 	unsigned int ien, iclr;
 	iclr = serial_in(port, SPRD_ICLR);
 	ien = serial_in(port, SPRD_IEN);
 	iclr |= SPRD_IEN_TX_EMPTY;
 	ien &= ~SPRD_IEN_TX_EMPTY;
 	serial_out(port, SPRD_ICLR, iclr);
 	serial_out(port, SPRD_IEN, ien);
 }
 static void sprd_start_tx(struct uart_port *port)
 {
 	unsigned int ien;
 	ien = serial_in(port, SPRD_IEN);
 	if (!(ien & SPRD_IEN_TX_EMPTY)) {
 		ien |= SPRD_IEN_TX_EMPTY;
 		serial_out(port, SPRD_IEN, ien);
 	}
 }
 static void sprd_stop_rx(struct uart_port *port)
 {
 	unsigned int ien, iclr;
 	iclr = serial_in(port, SPRD_ICLR);
 	ien = serial_in(port, SPRD_IEN);
 	ien &= ~(SPRD_IEN_RX_FULL | SPRD_IEN_BREAK_DETECT);
 	iclr |= SPRD_IEN_RX_FULL | SPRD_IEN_BREAK_DETECT;
 	serial_out(port, SPRD_IEN, ien);
 	serial_out(port, SPRD_ICLR, iclr);
 }
 /* The Sprd serial does not support this function. */
 static void sprd_break_ctl(struct uart_port *port, int break_state)
 {
 	/* nothing to do */
 }
 static int handle_lsr_errors(struct uart_port *port,
 			     unsigned int *flag,
 			     unsigned int *lsr)
 {
 	int ret = 0;
 	/* statistics */
 	if (*lsr & SPRD_LSR_BI) {
 		*lsr &= ~(SPRD_LSR_FE | SPRD_LSR_PE);
 		port->icount.brk++;
 		ret = uart_handle_break(port);
 		if (ret)
 			return ret;
 	} else if (*lsr & SPRD_LSR_PE)
 		port->icount.parity++;
 	else if (*lsr & SPRD_LSR_FE)
 		port->icount.frame++;
 	if (*lsr & SPRD_LSR_OE)
 		port->icount.overrun++;
 	/* mask off conditions which should be ignored */
 	*lsr &= port->read_status_mask;
 	if (*lsr & SPRD_LSR_BI)
 		*flag = TTY_BREAK;
 	else if (*lsr & SPRD_LSR_PE)
 		*flag = TTY_PARITY;
 	else if (*lsr & SPRD_LSR_FE)
 		*flag = TTY_FRAME;
 	return ret;
 }
 static inline void sprd_rx(struct uart_port *port)
 {
 	struct tty_port *tty = &port->state->port;
 	unsigned int ch, flag, lsr, max_count = SPRD_TIMEOUT;
 	while ((serial_in(port, SPRD_STS1) & 0x00ff) && max_count--) {
 		lsr = serial_in(port, SPRD_LSR);
 		ch = serial_in(port, SPRD_RXD);
 		flag = TTY_NORMAL;
 		port->icount.rx++;
 		if (lsr & (SPRD_LSR_BI | SPRD_LSR_PE |
 			SPRD_LSR_FE | SPRD_LSR_OE))
 			if (handle_lsr_errors(port, &lsr, &flag))
 				continue;
 		if (uart_handle_sysrq_char(port, ch))
 			continue;
 		uart_insert_char(port, lsr, SPRD_LSR_OE, ch, flag);
 	}
 	tty_flip_buffer_push(tty);
 }
 static inline void sprd_tx(struct uart_port *port)
 {
 	struct circ_buf *xmit = &port->state->xmit;
 	int count;
 	if (port->x_char) {
 		serial_out(port, SPRD_TXD, port->x_char);
 		port->icount.tx++;
 		port->x_char = 0;
 		return;
 	}
 	if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
 		sprd_stop_tx(port);
 		return;
 	}
 	count = THLD_TX_EMPTY;
 	do {
 		serial_out(port, SPRD_TXD, xmit->buf[xmit->tail]);
 		xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 		port->icount.tx++;
 		if (uart_circ_empty(xmit))
 			break;
 	} while (--count > 0);
 	if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 		uart_write_wakeup(port);
 	if (uart_circ_empty(xmit))
 		sprd_stop_tx(port);
 }
 /* this handles the interrupt from one port */
 static irqreturn_t sprd_handle_irq(int irq, void *dev_id)
 {
 	struct uart_port *port = dev_id;
 	unsigned int ims;
 	spin_lock(&port->lock);
 	ims = serial_in(port, SPRD_IMSR);
-	if (!ims)
+	if (!ims) {
+		spin_unlock(&port->lock);
 		return IRQ_NONE;
+	}
 	serial_out(port, SPRD_ICLR, ~0);
 	if (ims & (SPRD_IMSR_RX_FIFO_FULL |
 		SPRD_IMSR_BREAK_DETECT | SPRD_IMSR_TIMEOUT))
 		sprd_rx(port);
 	if (ims & SPRD_IMSR_TX_FIFO_EMPTY)
 		sprd_tx(port);
 	spin_unlock(&port->lock);
 	return IRQ_HANDLED;
 }
 static int sprd_startup(struct uart_port *port)
 {
 	int ret = 0;
 	unsigned int ien, fc;
 	unsigned int timeout;
 	struct sprd_uart_port *sp;
 	unsigned long flags;
 	serial_out(port, SPRD_CTL2, ((THLD_TX_EMPTY << 8) | THLD_RX_FULL));
 	/* clear rx fifo */
 	timeout = SPRD_TIMEOUT;
 	while (timeout-- && serial_in(port, SPRD_STS1) & 0x00ff)
 		serial_in(port, SPRD_RXD);
 	/* clear tx fifo */
 	timeout = SPRD_TIMEOUT;
 	while (timeout-- && serial_in(port, SPRD_STS1) & 0xff00)
 		cpu_relax();
 	/* clear interrupt */
 	serial_out(port, SPRD_IEN, 0);
 	serial_out(port, SPRD_ICLR, ~0);
 	/* allocate irq */
 	sp = container_of(port, struct sprd_uart_port, port);
 	snprintf(sp->name, sizeof(sp->name), "sprd_serial%d", port->line);
 	ret = devm_request_irq(port->dev, port->irq, sprd_handle_irq,
 				IRQF_SHARED, sp->name, port);
 	if (ret) {
 		dev_err(port->dev, "fail to request serial irq %d, ret=%d\n",
 			port->irq, ret);
 		return ret;
 	}
 	fc = serial_in(port, SPRD_CTL1);
 	fc |= RX_TOUT_THLD_DEF | RX_HFC_THLD_DEF;
 	serial_out(port, SPRD_CTL1, fc);
 	/* enable interrupt */
 	spin_lock_irqsave(&port->lock, flags);
 	ien = serial_in(port, SPRD_IEN);
 	ien |= SPRD_IEN_RX_FULL | SPRD_IEN_BREAK_DETECT | SPRD_IEN_TIMEOUT;
 	serial_out(port, SPRD_IEN, ien);
 	spin_unlock_irqrestore(&port->lock, flags);
 	return 0;
 }
 static void sprd_shutdown(struct uart_port *port)
 {
 	serial_out(port, SPRD_IEN, 0);
 	serial_out(port, SPRD_ICLR, ~0);
 	devm_free_irq(port->dev, port->irq, port);
 }
 static void sprd_set_termios(struct uart_port *port,
 				    struct ktermios *termios,
 				    struct ktermios *old)
 {
 	unsigned int baud, quot;
 	unsigned int lcr = 0, fc;
 	unsigned long flags;
 	/* ask the core to calculate the divisor for us */
 	baud = uart_get_baud_rate(port, termios, old, 0, SPRD_BAUD_IO_LIMIT);
 	quot = (unsigned int)((port->uartclk + baud / 2) / baud);
 	/* set data length */
 	switch (termios->c_cflag & CSIZE) {
 	case CS5:
 		lcr |= SPRD_LCR_DATA_LEN5;
 		break;
 	case CS6:
 		lcr |= SPRD_LCR_DATA_LEN6;
 		break;
 	case CS7:
 		lcr |= SPRD_LCR_DATA_LEN7;
 		break;
 	case CS8:
 	default:
 		lcr |= SPRD_LCR_DATA_LEN8;
 		break;
 	}
 	/* calculate stop bits */
 	lcr &= ~(SPRD_LCR_STOP_1BIT | SPRD_LCR_STOP_2BIT);
 	if (termios->c_cflag & CSTOPB)
 		lcr |= SPRD_LCR_STOP_2BIT;
 	else
 		lcr |= SPRD_LCR_STOP_1BIT;
 	/* calculate parity */
 	lcr &= ~SPRD_LCR_PARITY;
 	termios->c_cflag &= ~CMSPAR;	/* no support mark/space */
 	if (termios->c_cflag & PARENB) {
 		lcr |= SPRD_LCR_PARITY_EN;
 		if (termios->c_cflag & PARODD)
 			lcr |= SPRD_LCR_ODD_PAR;
 		else
 			lcr |= SPRD_LCR_EVEN_PAR;
 	}
 	spin_lock_irqsave(&port->lock, flags);
 	/* update the per-port timeout */
 	uart_update_timeout(port, termios->c_cflag, baud);
 	port->read_status_mask = SPRD_LSR_OE;
 	if (termios->c_iflag & INPCK)
 		port->read_status_mask |= SPRD_LSR_FE | SPRD_LSR_PE;
 	if (termios->c_iflag & (IGNBRK | BRKINT | PARMRK))
 		port->read_status_mask |= SPRD_LSR_BI;
 	/* characters to ignore */
 	port->ignore_status_mask = 0;
 	if (termios->c_iflag & IGNPAR)
 		port->ignore_status_mask |= SPRD_LSR_PE | SPRD_LSR_FE;
 	if (termios->c_iflag & IGNBRK) {
 		port->ignore_status_mask |= SPRD_LSR_BI;
 		/*
 		 * If we're ignoring parity and break indicators,
 		 * ignore overruns too (for real raw support).
 		 */
 		if (termios->c_iflag & IGNPAR)
 			port->ignore_status_mask |= SPRD_LSR_OE;
 	}
 	/* flow control */
 	fc = serial_in(port, SPRD_CTL1);
 	fc &= ~(RX_HW_FLOW_CTL_THLD | RX_HW_FLOW_CTL_EN | TX_HW_FLOW_CTL_EN);
 	if (termios->c_cflag & CRTSCTS) {
 		fc |= RX_HW_FLOW_CTL_THLD;
 		fc |= RX_HW_FLOW_CTL_EN;
 		fc |= TX_HW_FLOW_CTL_EN;
 	}
 	/* clock divider bit0~bit15 */
 	serial_out(port, SPRD_CLKD0, quot & 0xffff);
 	/* clock divider bit16~bit20 */
 	serial_out(port, SPRD_CLKD1, (quot & 0x1f0000) >> 16);
 	serial_out(port, SPRD_LCR, lcr);
 	fc |= RX_TOUT_THLD_DEF | RX_HFC_THLD_DEF;
 	serial_out(port, SPRD_CTL1, fc);
 	spin_unlock_irqrestore(&port->lock, flags);
 	/* Don't rewrite B0 */
 	if (tty_termios_baud_rate(termios))
 		tty_termios_encode_baud_rate(termios, baud, baud);
 }
 static const char *sprd_type(struct uart_port *port)
 {
 	return "SPX";
 }
 static void sprd_release_port(struct uart_port *port)
 {
 	/* nothing to do */
 }
 static int sprd_request_port(struct uart_port *port)
 {
 	return 0;
 }
 static void sprd_config_port(struct uart_port *port, int flags)
 {
 	if (flags & UART_CONFIG_TYPE)
 		port->type = PORT_SPRD;
 }
 static int sprd_verify_port(struct uart_port *port,
 				   struct serial_struct *ser)
 {
 	if (ser->type != PORT_SPRD)
 		return -EINVAL;
 	if (port->irq != ser->irq)
 		return -EINVAL;
 	return 0;
 }
 static struct uart_ops serial_sprd_ops = {
 	.tx_empty = sprd_tx_empty,
 	.get_mctrl = sprd_get_mctrl,
 	.set_mctrl = sprd_set_mctrl,
 	.stop_tx = sprd_stop_tx,
 	.start_tx = sprd_start_tx,
 	.stop_rx = sprd_stop_rx,
 	.break_ctl = sprd_break_ctl,
 	.startup = sprd_startup,
 	.shutdown = sprd_shutdown,
 	.set_termios = sprd_set_termios,
 	.type = sprd_type,
 	.release_port = sprd_release_port,
 	.request_port = sprd_request_port,
 	.config_port = sprd_config_port,
 	.verify_port = sprd_verify_port,
 };
 #ifdef CONFIG_SERIAL_SPRD_CONSOLE
 static inline void wait_for_xmitr(struct uart_port *port)
 {
 	unsigned int status, tmout = 10000;
 	/* wait up to 10ms for the character(s) to be sent */
 	do {
 		status = serial_in(port, SPRD_STS1);
 		if (--tmout == 0)
 			break;
 		udelay(1);
 	} while (status & 0xff00);
 }
 static void sprd_console_putchar(struct uart_port *port, int ch)
 {
 	wait_for_xmitr(port);
 	serial_out(port, SPRD_TXD, ch);
 }
 static void sprd_console_write(struct console *co, const char *s,
 				      unsigned int count)
 {
 	struct uart_port *port = &sprd_port[co->index]->port;
 	int locked = 1;
 	unsigned long flags;
 	if (port->sysrq)
 		locked = 0;
 	else if (oops_in_progress)
 		locked = spin_trylock_irqsave(&port->lock, flags);
 	else
 		spin_lock_irqsave(&port->lock, flags);
 	uart_console_write(port, s, count, sprd_console_putchar);
 	/* wait for transmitter to become empty */
 	wait_for_xmitr(port);
 	if (locked)
 		spin_unlock_irqrestore(&port->lock, flags);
 }
 static int __init sprd_console_setup(struct console *co, char *options)
 {
 	struct uart_port *port;
 	int baud = 115200;
 	int bits = 8;
 	int parity = 'n';
 	int flow = 'n';
 	if (co->index >= UART_NR_MAX || co->index < 0)
 		co->index = 0;
 	port = &sprd_port[co->index]->port;
 	if (port == NULL) {
 		pr_info("serial port %d not yet initialized\n", co->index);
 		return -ENODEV;
 	}
 	if (options)
 		uart_parse_options(options, &baud, &parity, &bits, &flow);
 	return uart_set_options(port, co, baud, parity, bits, flow);
 }
 static struct uart_driver sprd_uart_driver;
 static struct console sprd_console = {
 	.name = SPRD_TTY_NAME,
 	.write = sprd_console_write,
 	.device = uart_console_device,
 	.setup = sprd_console_setup,
 	.flags = CON_PRINTBUFFER,
 	.index = -1,
 	.data = &sprd_uart_driver,
 };
 #define SPRD_CONSOLE	(&sprd_console)
 /* Support for earlycon */
 static void sprd_putc(struct uart_port *port, int c)
 {
 	unsigned int timeout = SPRD_TIMEOUT;
 	while (timeout-- &&
 		   !(readl(port->membase + SPRD_LSR) & SPRD_LSR_TX_OVER))
 		cpu_relax();
 	writeb(c, port->membase + SPRD_TXD);
 }
 static void sprd_early_write(struct console *con, const char *s,
 				    unsigned n)
 {
 	struct earlycon_device *dev = con->data;
 	uart_console_write(&dev->port, s, n, sprd_putc);
 }
 static int __init sprd_early_console_setup(
 				struct earlycon_device *device,
 				const char *opt)
 {
 	if (!device->port.membase)
 		return -ENODEV;
 	device->con->write = sprd_early_write;
 	return 0;
 }
 EARLYCON_DECLARE(sprd_serial, sprd_early_console_setup);
 OF_EARLYCON_DECLARE(sprd_serial, "sprd,sc9836-uart",
 		    sprd_early_console_setup);
 #else /* !CONFIG_SERIAL_SPRD_CONSOLE */
 #define SPRD_CONSOLE		NULL
 #endif
 static struct uart_driver sprd_uart_driver = {
 	.owner = THIS_MODULE,
 	.driver_name = "sprd_serial",
 	.dev_name = SPRD_TTY_NAME,
 	.major = 0,
 	.minor = 0,
 	.nr = UART_NR_MAX,
 	.cons = SPRD_CONSOLE,
 };
 static int sprd_probe_dt_alias(int index, struct device *dev)
 {
 	struct device_node *np;
 	int ret = index;
 	if (!IS_ENABLED(CONFIG_OF))
 		return ret;
 	np = dev->of_node;
 	if (!np)
 		return ret;
 	ret = of_alias_get_id(np, "serial");
 	if (IS_ERR_VALUE(ret))
 		ret = index;
 	else if (ret >= ARRAY_SIZE(sprd_port) || sprd_port[ret] != NULL) {
 		dev_warn(dev, "requested serial port %d not available.\n", ret);
 		ret = index;
 	}
 	return ret;
 }
 static int sprd_remove(struct platform_device *dev)
 {
 	struct sprd_uart_port *sup = platform_get_drvdata(dev);
 	if (sup) {
 		uart_remove_one_port(&sprd_uart_driver, &sup->port);
 		sprd_port[sup->port.line] = NULL;
 		sprd_ports_num--;
 	}
 	if (!sprd_ports_num)
 		uart_unregister_driver(&sprd_uart_driver);
 	return 0;
 }
 static int sprd_probe(struct platform_device *pdev)
 {
 	struct resource *res;
 	struct uart_port *up;
 	struct clk *clk;
 	int irq;
 	int index;
 	int ret;
 	for (index = 0; index < ARRAY_SIZE(sprd_port); index++)
 		if (sprd_port[index] == NULL)
 			break;
 	if (index == ARRAY_SIZE(sprd_port))
 		return -EBUSY;
 	index = sprd_probe_dt_alias(index, &pdev->dev);
 	sprd_port[index] = devm_kzalloc(&pdev->dev,
 		sizeof(*sprd_port[index]), GFP_KERNEL);
 	if (!sprd_port[index])
 		return -ENOMEM;
 	up = &sprd_port[index]->port;
 	up->dev = &pdev->dev;
 	up->line = index;
 	up->type = PORT_SPRD;
 	up->iotype = SERIAL_IO_PORT;
 	up->uartclk = SPRD_DEF_RATE;
 	up->fifosize = SPRD_FIFO_SIZE;
 	up->ops = &serial_sprd_ops;
 	up->flags = UPF_BOOT_AUTOCONF;
 	clk = devm_clk_get(&pdev->dev, NULL);
 	if (!IS_ERR(clk))
 		up->uartclk = clk_get_rate(clk);
 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!res) {
 		dev_err(&pdev->dev, "not provide mem resource\n");
 		return -ENODEV;
 	}
 	up->mapbase = res->start;
 	up->membase = devm_ioremap_resource(&pdev->dev, res);
 	if (IS_ERR(up->membase))
 		return PTR_ERR(up->membase);
 	irq = platform_get_irq(pdev, 0);
 	if (irq < 0) {
 		dev_err(&pdev->dev, "not provide irq resource\n");
 		return -ENODEV;
 	}
 	up->irq = irq;
 	if (!sprd_ports_num) {
 		ret = uart_register_driver(&sprd_uart_driver);
 		if (ret < 0) {
 			pr_err("Failed to register SPRD-UART driver\n");
 			return ret;
 		}
 	}
 	sprd_ports_num++;
 	ret = uart_add_one_port(&sprd_uart_driver, up);
 	if (ret) {
 		sprd_port[index] = NULL;
 		sprd_remove(pdev);
 	}
 	platform_set_drvdata(pdev, up);
 	return ret;
 }
 static int sprd_suspend(struct device *dev)
 {
 	struct sprd_uart_port *sup = dev_get_drvdata(dev);
 	uart_suspend_port(&sprd_uart_driver, &sup->port);
 	return 0;
 }
 static int sprd_resume(struct device *dev)
 {
 	struct sprd_uart_port *sup = dev_get_drvdata(dev);
 	uart_resume_port(&sprd_uart_driver, &sup->port);
 	return 0;
 }
 static SIMPLE_DEV_PM_OPS(sprd_pm_ops, sprd_suspend, sprd_resume);
 static const struct of_device_id serial_ids[] = {
 	{.compatible = "sprd,sc9836-uart",},
 	{}
 };
 static struct platform_driver sprd_platform_driver = {
 	.probe		= sprd_probe,
 	.remove		= sprd_remove,
 	.driver		= {
 		.name	= "sprd_serial",
 		.of_match_table = of_match_ptr(serial_ids),
 		.pm	= &sprd_pm_ops,
 	},
 };
 module_platform_driver(sprd_platform_driver);
 MODULE_LICENSE("GPL v2");
 MODULE_DESCRIPTION("Spreadtrum SoC serial driver series");

drivers/tty/tty_io.c

Diff comments View file @ bbbce51

1	/*	1	/*
2	* Copyright (C) 1991, 1992 Linus Torvalds	2	* Copyright (C) 1991, 1992 Linus Torvalds
3	*/	3	*/
4		4
5	/*	5	/*
6	* 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles	6	* 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
7	* or rs-channels. It also implements echoing, cooked mode etc.	7	* or rs-channels. It also implements echoing, cooked mode etc.
8	*	8	*
9	* Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.	9	* Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
10	*	10	*
11	* Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the	11	* Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
12	* tty_struct and tty_queue structures. Previously there was an array	12	* tty_struct and tty_queue structures. Previously there was an array
13	* of 256 tty_struct's which was statically allocated, and the	13	* of 256 tty_struct's which was statically allocated, and the
14	* tty_queue structures were allocated at boot time. Both are now	14	* tty_queue structures were allocated at boot time. Both are now
15	* dynamically allocated only when the tty is open.	15	* dynamically allocated only when the tty is open.
16	*	16	*
17	* Also restructured routines so that there is more of a separation	17	* Also restructured routines so that there is more of a separation
18	* between the high-level tty routines (tty_io.c and tty_ioctl.c) and	18	* between the high-level tty routines (tty_io.c and tty_ioctl.c) and
19	* the low-level tty routines (serial.c, pty.c, console.c). This	19	* the low-level tty routines (serial.c, pty.c, console.c). This
20	* makes for cleaner and more compact code. -TYT, 9/17/92	20	* makes for cleaner and more compact code. -TYT, 9/17/92
21	*	21	*
22	* Modified by Fred N. van Kempen, 01/29/93, to add line disciplines	22	* Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
23	* which can be dynamically activated and de-activated by the line	23	* which can be dynamically activated and de-activated by the line
24	* discipline handling modules (like SLIP).	24	* discipline handling modules (like SLIP).
25	*	25	*
26	* NOTE: pay no attention to the line discipline code (yet); its	26	* NOTE: pay no attention to the line discipline code (yet); its
27	* interface is still subject to change in this version...	27	* interface is still subject to change in this version...
28	* -- TYT, 1/31/92	28	* -- TYT, 1/31/92
29	*	29	*
30	* Added functionality to the OPOST tty handling. No delays, but all	30	* Added functionality to the OPOST tty handling. No delays, but all
31	* other bits should be there.	31	* other bits should be there.
32	* -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.	32	* -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
33	*	33	*
34	* Rewrote canonical mode and added more termios flags.	34	* Rewrote canonical mode and added more termios flags.
35	* -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94	35	* -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
36	*	36	*
37	* Reorganized FASYNC support so mouse code can share it.	37	* Reorganized FASYNC support so mouse code can share it.
38	* -- ctm@ardi.com, 9Sep95	38	* -- ctm@ardi.com, 9Sep95
39	*	39	*
40	* New TIOCLINUX variants added.	40	* New TIOCLINUX variants added.
41	* -- mj@k332.feld.cvut.cz, 19-Nov-95	41	* -- mj@k332.feld.cvut.cz, 19-Nov-95
42	*	42	*
43	* Restrict vt switching via ioctl()	43	* Restrict vt switching via ioctl()
44	* -- grif@cs.ucr.edu, 5-Dec-95	44	* -- grif@cs.ucr.edu, 5-Dec-95
45	*	45	*
46	* Move console and virtual terminal code to more appropriate files,	46	* Move console and virtual terminal code to more appropriate files,
47	* implement CONFIG_VT and generalize console device interface.	47	* implement CONFIG_VT and generalize console device interface.
48	* -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97	48	* -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
49	*	49	*
50	* Rewrote tty_init_dev and tty_release_dev to eliminate races.	50	* Rewrote tty_init_dev and tty_release_dev to eliminate races.
51	* -- Bill Hawes <whawes@star.net>, June 97	51	* -- Bill Hawes <whawes@star.net>, June 97
52	*	52	*
53	* Added devfs support.	53	* Added devfs support.
54	* -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998	54	* -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
55	*	55	*
56	* Added support for a Unix98-style ptmx device.	56	* Added support for a Unix98-style ptmx device.
57	* -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998	57	* -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
58	*	58	*
59	* Reduced memory usage for older ARM systems	59	* Reduced memory usage for older ARM systems
60	* -- Russell King <rmk@arm.linux.org.uk>	60	* -- Russell King <rmk@arm.linux.org.uk>
61	*	61	*
62	* Move do_SAK() into process context. Less stack use in devfs functions.	62	* Move do_SAK() into process context. Less stack use in devfs functions.
63	* alloc_tty_struct() always uses kmalloc()	63	* alloc_tty_struct() always uses kmalloc()
64	* -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01	64	* -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
65	*/	65	*/
66		66
67	#include <linux/types.h>	67	#include <linux/types.h>
68	#include <linux/major.h>	68	#include <linux/major.h>
69	#include <linux/errno.h>	69	#include <linux/errno.h>
70	#include <linux/signal.h>	70	#include <linux/signal.h>
71	#include <linux/fcntl.h>	71	#include <linux/fcntl.h>
72	#include <linux/sched.h>	72	#include <linux/sched.h>
73	#include <linux/interrupt.h>	73	#include <linux/interrupt.h>
74	#include <linux/tty.h>	74	#include <linux/tty.h>
75	#include <linux/tty_driver.h>	75	#include <linux/tty_driver.h>
76	#include <linux/tty_flip.h>	76	#include <linux/tty_flip.h>
77	#include <linux/devpts_fs.h>	77	#include <linux/devpts_fs.h>
78	#include <linux/file.h>	78	#include <linux/file.h>
79	#include <linux/fdtable.h>	79	#include <linux/fdtable.h>
80	#include <linux/console.h>	80	#include <linux/console.h>
81	#include <linux/timer.h>	81	#include <linux/timer.h>
82	#include <linux/ctype.h>	82	#include <linux/ctype.h>
83	#include <linux/kd.h>	83	#include <linux/kd.h>
84	#include <linux/mm.h>	84	#include <linux/mm.h>
85	#include <linux/string.h>	85	#include <linux/string.h>
86	#include <linux/slab.h>	86	#include <linux/slab.h>
87	#include <linux/poll.h>	87	#include <linux/poll.h>
88	#include <linux/proc_fs.h>	88	#include <linux/proc_fs.h>
89	#include <linux/init.h>	89	#include <linux/init.h>
90	#include <linux/module.h>	90	#include <linux/module.h>
91	#include <linux/device.h>	91	#include <linux/device.h>
92	#include <linux/wait.h>	92	#include <linux/wait.h>
93	#include <linux/bitops.h>	93	#include <linux/bitops.h>
94	#include <linux/delay.h>	94	#include <linux/delay.h>
95	#include <linux/seq_file.h>	95	#include <linux/seq_file.h>
96	#include <linux/serial.h>	96	#include <linux/serial.h>
97	#include <linux/ratelimit.h>	97	#include <linux/ratelimit.h>
98		98
99	#include <linux/uaccess.h>	99	#include <linux/uaccess.h>
100		100
101	#include <linux/kbd_kern.h>	101	#include <linux/kbd_kern.h>
102	#include <linux/vt_kern.h>	102	#include <linux/vt_kern.h>
103	#include <linux/selection.h>	103	#include <linux/selection.h>
104		104
105	#include <linux/kmod.h>	105	#include <linux/kmod.h>
106	#include <linux/nsproxy.h>	106	#include <linux/nsproxy.h>
107		107
108	#undef TTY_DEBUG_HANGUP	108	#undef TTY_DEBUG_HANGUP
109		109
110	#define TTY_PARANOIA_CHECK 1	110	#define TTY_PARANOIA_CHECK 1
111	#define CHECK_TTY_COUNT 1	111	#define CHECK_TTY_COUNT 1
112		112
113	struct ktermios tty_std_termios = { /* for the benefit of tty drivers */	113	struct ktermios tty_std_termios = { /* for the benefit of tty drivers */
114	.c_iflag = ICRNL \| IXON,	114	.c_iflag = ICRNL \| IXON,
115	.c_oflag = OPOST \| ONLCR,	115	.c_oflag = OPOST \| ONLCR,
116	.c_cflag = B38400 \| CS8 \| CREAD \| HUPCL,	116	.c_cflag = B38400 \| CS8 \| CREAD \| HUPCL,
117	.c_lflag = ISIG \| ICANON \| ECHO \| ECHOE \| ECHOK \|	117	.c_lflag = ISIG \| ICANON \| ECHO \| ECHOE \| ECHOK \|
118	ECHOCTL \| ECHOKE \| IEXTEN,	118	ECHOCTL \| ECHOKE \| IEXTEN,
119	.c_cc = INIT_C_CC,	119	.c_cc = INIT_C_CC,
120	.c_ispeed = 38400,	120	.c_ispeed = 38400,
121	.c_ospeed = 38400	121	.c_ospeed = 38400
122	};	122	};
123		123
124	EXPORT_SYMBOL(tty_std_termios);	124	EXPORT_SYMBOL(tty_std_termios);
125		125
126	/* This list gets poked at by procfs and various bits of boot up code. This	126	/* This list gets poked at by procfs and various bits of boot up code. This
127	could do with some rationalisation such as pulling the tty proc function	127	could do with some rationalisation such as pulling the tty proc function
128	into this file */	128	into this file */
129		129
130	LIST_HEAD(tty_drivers); /* linked list of tty drivers */	130	LIST_HEAD(tty_drivers); /* linked list of tty drivers */
131		131
132	/* Mutex to protect creating and releasing a tty. This is shared with	132	/* Mutex to protect creating and releasing a tty. This is shared with
133	vt.c for deeply disgusting hack reasons */	133	vt.c for deeply disgusting hack reasons */
134	DEFINE_MUTEX(tty_mutex);	134	DEFINE_MUTEX(tty_mutex);
135	EXPORT_SYMBOL(tty_mutex);	135	EXPORT_SYMBOL(tty_mutex);
136		136
137	/* Spinlock to protect the tty->tty_files list */	137	/* Spinlock to protect the tty->tty_files list */
138	DEFINE_SPINLOCK(tty_files_lock);	138	DEFINE_SPINLOCK(tty_files_lock);
139		139
140	static ssize_t tty_read(struct file , char __user , size_t, loff_t *);	140	static ssize_t tty_read(struct file , char __user , size_t, loff_t *);
141	static ssize_t tty_write(struct file , const char __user , size_t, loff_t *);	141	static ssize_t tty_write(struct file , const char __user , size_t, loff_t *);
142	ssize_t redirected_tty_write(struct file , const char __user ,	142	ssize_t redirected_tty_write(struct file , const char __user ,
143	size_t, loff_t *);	143	size_t, loff_t *);
144	static unsigned int tty_poll(struct file , poll_table );	144	static unsigned int tty_poll(struct file , poll_table );
145	static int tty_open(struct inode , struct file );	145	static int tty_open(struct inode , struct file );
146	long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);	146	long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
147	#ifdef CONFIG_COMPAT	147	#ifdef CONFIG_COMPAT
148	static long tty_compat_ioctl(struct file *file, unsigned int cmd,	148	static long tty_compat_ioctl(struct file *file, unsigned int cmd,
149	unsigned long arg);	149	unsigned long arg);
150	#else	150	#else
151	#define tty_compat_ioctl NULL	151	#define tty_compat_ioctl NULL
152	#endif	152	#endif
153	static int __tty_fasync(int fd, struct file *filp, int on);	153	static int __tty_fasync(int fd, struct file *filp, int on);
154	static int tty_fasync(int fd, struct file *filp, int on);	154	static int tty_fasync(int fd, struct file *filp, int on);
155	static void release_tty(struct tty_struct *tty, int idx);	155	static void release_tty(struct tty_struct *tty, int idx);
156		156
157	/**	157	/**
158	* free_tty_struct - free a disused tty	158	* free_tty_struct - free a disused tty
159	* @tty: tty struct to free	159	* @tty: tty struct to free
160	*	160	*
161	* Free the write buffers, tty queue and tty memory itself.	161	* Free the write buffers, tty queue and tty memory itself.
162	*	162	*
163	* Locking: none. Must be called after tty is definitely unused	163	* Locking: none. Must be called after tty is definitely unused
164	*/	164	*/
165		165
166	void free_tty_struct(struct tty_struct *tty)	166	void free_tty_struct(struct tty_struct *tty)
167	{	167	{
168	if (!tty)	168	if (!tty)
169	return;	169	return;
170	put_device(tty->dev);	170	put_device(tty->dev);
171	kfree(tty->write_buf);	171	kfree(tty->write_buf);
172	tty->magic = 0xDEADDEAD;	172	tty->magic = 0xDEADDEAD;
173	kfree(tty);	173	kfree(tty);
174	}	174	}
175		175
176	static inline struct tty_struct file_tty(struct file file)	176	static inline struct tty_struct file_tty(struct file file)
177	{	177	{
178	return ((struct tty_file_private *)file->private_data)->tty;	178	return ((struct tty_file_private *)file->private_data)->tty;
179	}	179	}
180		180
181	int tty_alloc_file(struct file *file)	181	int tty_alloc_file(struct file *file)
182	{	182	{
183	struct tty_file_private *priv;	183	struct tty_file_private *priv;
184		184
185	priv = kmalloc(sizeof(*priv), GFP_KERNEL);	185	priv = kmalloc(sizeof(*priv), GFP_KERNEL);
186	if (!priv)	186	if (!priv)
187	return -ENOMEM;	187	return -ENOMEM;
188		188
189	file->private_data = priv;	189	file->private_data = priv;
190		190
191	return 0;	191	return 0;
192	}	192	}
193		193
194	/* Associate a new file with the tty structure */	194	/* Associate a new file with the tty structure */
195	void tty_add_file(struct tty_struct tty, struct file file)	195	void tty_add_file(struct tty_struct tty, struct file file)
196	{	196	{
197	struct tty_file_private *priv = file->private_data;	197	struct tty_file_private *priv = file->private_data;
198		198
199	priv->tty = tty;	199	priv->tty = tty;
200	priv->file = file;	200	priv->file = file;
201		201
202	spin_lock(&tty_files_lock);	202	spin_lock(&tty_files_lock);
203	list_add(&priv->list, &tty->tty_files);	203	list_add(&priv->list, &tty->tty_files);
204	spin_unlock(&tty_files_lock);	204	spin_unlock(&tty_files_lock);
205	}	205	}
206		206
207	/**	207	/**
208	* tty_free_file - free file->private_data	208	* tty_free_file - free file->private_data
209	*	209	*
210	* This shall be used only for fail path handling when tty_add_file was not	210	* This shall be used only for fail path handling when tty_add_file was not
211	* called yet.	211	* called yet.
212	*/	212	*/
213	void tty_free_file(struct file *file)	213	void tty_free_file(struct file *file)
214	{	214	{
215	struct tty_file_private *priv = file->private_data;	215	struct tty_file_private *priv = file->private_data;
216		216
217	file->private_data = NULL;	217	file->private_data = NULL;
218	kfree(priv);	218	kfree(priv);
219	}	219	}
220		220
221	/* Delete file from its tty */	221	/* Delete file from its tty */
222	static void tty_del_file(struct file *file)	222	static void tty_del_file(struct file *file)
223	{	223	{
224	struct tty_file_private *priv = file->private_data;	224	struct tty_file_private *priv = file->private_data;
225		225
226	spin_lock(&tty_files_lock);	226	spin_lock(&tty_files_lock);
227	list_del(&priv->list);	227	list_del(&priv->list);
228	spin_unlock(&tty_files_lock);	228	spin_unlock(&tty_files_lock);
229	tty_free_file(file);	229	tty_free_file(file);
230	}	230	}
231		231
232		232
233	#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)	233	#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
234		234
235	/**	235	/**
236	* tty_name - return tty naming	236	* tty_name - return tty naming
237	* @tty: tty structure	237	* @tty: tty structure
238	* @buf: buffer for output	238	* @buf: buffer for output
239	*	239	*
240	* Convert a tty structure into a name. The name reflects the kernel	240	* Convert a tty structure into a name. The name reflects the kernel
241	* naming policy and if udev is in use may not reflect user space	241	* naming policy and if udev is in use may not reflect user space
242	*	242	*
243	* Locking: none	243	* Locking: none
244	*/	244	*/
245		245
246	char tty_name(struct tty_struct tty, char *buf)	246	char tty_name(struct tty_struct tty, char *buf)
247	{	247	{
248	if (!tty) /* Hmm. NULL pointer. That's fun. */	248	if (!tty) /* Hmm. NULL pointer. That's fun. */
249	strcpy(buf, "NULL tty");	249	strcpy(buf, "NULL tty");
250	else	250	else
251	strcpy(buf, tty->name);	251	strcpy(buf, tty->name);
252	return buf;	252	return buf;
253	}	253	}
254		254
255	EXPORT_SYMBOL(tty_name);	255	EXPORT_SYMBOL(tty_name);
256		256
257	int tty_paranoia_check(struct tty_struct tty, struct inode inode,	257	int tty_paranoia_check(struct tty_struct tty, struct inode inode,
258	const char *routine)	258	const char *routine)
259	{	259	{
260	#ifdef TTY_PARANOIA_CHECK	260	#ifdef TTY_PARANOIA_CHECK
261	if (!tty) {	261	if (!tty) {
262	printk(KERN_WARNING	262	printk(KERN_WARNING
263	"null TTY for (%d:%d) in %s\n",	263	"null TTY for (%d:%d) in %s\n",
264	imajor(inode), iminor(inode), routine);	264	imajor(inode), iminor(inode), routine);
265	return 1;	265	return 1;
266	}	266	}
267	if (tty->magic != TTY_MAGIC) {	267	if (tty->magic != TTY_MAGIC) {
268	printk(KERN_WARNING	268	printk(KERN_WARNING
269	"bad magic number for tty struct (%d:%d) in %s\n",	269	"bad magic number for tty struct (%d:%d) in %s\n",
270	imajor(inode), iminor(inode), routine);	270	imajor(inode), iminor(inode), routine);
271	return 1;	271	return 1;
272	}	272	}
273	#endif	273	#endif
274	return 0;	274	return 0;
275	}	275	}
276		276
277	/* Caller must hold tty_lock */	277	/* Caller must hold tty_lock */
278	static int check_tty_count(struct tty_struct tty, const char routine)	278	static int check_tty_count(struct tty_struct tty, const char routine)
279	{	279	{
280	#ifdef CHECK_TTY_COUNT	280	#ifdef CHECK_TTY_COUNT
281	struct list_head *p;	281	struct list_head *p;
282	int count = 0;	282	int count = 0;
283		283
284	spin_lock(&tty_files_lock);	284	spin_lock(&tty_files_lock);
285	list_for_each(p, &tty->tty_files) {	285	list_for_each(p, &tty->tty_files) {
286	count++;	286	count++;
287	}	287	}
288	spin_unlock(&tty_files_lock);	288	spin_unlock(&tty_files_lock);
289	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&	289	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
290	tty->driver->subtype == PTY_TYPE_SLAVE &&	290	tty->driver->subtype == PTY_TYPE_SLAVE &&
291	tty->link && tty->link->count)	291	tty->link && tty->link->count)
292	count++;	292	count++;
293	if (tty->count != count) {	293	if (tty->count != count) {
294	printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "	294	printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
295	"!= #fd's(%d) in %s\n",	295	"!= #fd's(%d) in %s\n",
296	tty->name, tty->count, count, routine);	296	tty->name, tty->count, count, routine);
297	return count;	297	return count;
298	}	298	}
299	#endif	299	#endif
300	return 0;	300	return 0;
301	}	301	}
302		302
303	/**	303	/**
304	* get_tty_driver - find device of a tty	304	* get_tty_driver - find device of a tty
305	* @dev_t: device identifier	305	* @dev_t: device identifier
306	* @index: returns the index of the tty	306	* @index: returns the index of the tty
307	*	307	*
308	* This routine returns a tty driver structure, given a device number	308	* This routine returns a tty driver structure, given a device number
309	* and also passes back the index number.	309	* and also passes back the index number.
310	*	310	*
311	* Locking: caller must hold tty_mutex	311	* Locking: caller must hold tty_mutex
312	*/	312	*/
313		313
314	static struct tty_driver get_tty_driver(dev_t device, int index)	314	static struct tty_driver get_tty_driver(dev_t device, int index)
315	{	315	{
316	struct tty_driver *p;	316	struct tty_driver *p;
317		317
318	list_for_each_entry(p, &tty_drivers, tty_drivers) {	318	list_for_each_entry(p, &tty_drivers, tty_drivers) {
319	dev_t base = MKDEV(p->major, p->minor_start);	319	dev_t base = MKDEV(p->major, p->minor_start);
320	if (device < base \|\| device >= base + p->num)	320	if (device < base \|\| device >= base + p->num)
321	continue;	321	continue;
322	*index = device - base;	322	*index = device - base;
323	return tty_driver_kref_get(p);	323	return tty_driver_kref_get(p);
324	}	324	}
325	return NULL;	325	return NULL;
326	}	326	}
327		327
328	#ifdef CONFIG_CONSOLE_POLL	328	#ifdef CONFIG_CONSOLE_POLL
329		329
330	/**	330	/**
331	* tty_find_polling_driver - find device of a polled tty	331	* tty_find_polling_driver - find device of a polled tty
332	* @name: name string to match	332	* @name: name string to match
333	* @line: pointer to resulting tty line nr	333	* @line: pointer to resulting tty line nr
334	*	334	*
335	* This routine returns a tty driver structure, given a name	335	* This routine returns a tty driver structure, given a name
336	* and the condition that the tty driver is capable of polled	336	* and the condition that the tty driver is capable of polled
337	* operation.	337	* operation.
338	*/	338	*/
339	struct tty_driver tty_find_polling_driver(char name, int *line)	339	struct tty_driver tty_find_polling_driver(char name, int *line)
340	{	340	{
341	struct tty_driver p, res = NULL;	341	struct tty_driver p, res = NULL;
342	int tty_line = 0;	342	int tty_line = 0;
343	int len;	343	int len;
344	char str, stp;	344	char str, stp;
345		345
346	for (str = name; *str; str++)	346	for (str = name; *str; str++)
347	if ((str >= '0' && str <= '9') \|\| *str == ',')	347	if ((str >= '0' && str <= '9') \|\| *str == ',')
348	break;	348	break;
349	if (!*str)	349	if (!*str)
350	return NULL;	350	return NULL;
351		351
352	len = str - name;	352	len = str - name;
353	tty_line = simple_strtoul(str, &str, 10);	353	tty_line = simple_strtoul(str, &str, 10);
354		354
355	mutex_lock(&tty_mutex);	355	mutex_lock(&tty_mutex);
356	/* Search through the tty devices to look for a match */	356	/* Search through the tty devices to look for a match */
357	list_for_each_entry(p, &tty_drivers, tty_drivers) {	357	list_for_each_entry(p, &tty_drivers, tty_drivers) {
358	if (strncmp(name, p->name, len) != 0)	358	if (strncmp(name, p->name, len) != 0)
359	continue;	359	continue;
360	stp = str;	360	stp = str;
361	if (*stp == ',')	361	if (*stp == ',')
362	stp++;	362	stp++;
363	if (*stp == '\0')	363	if (*stp == '\0')
364	stp = NULL;	364	stp = NULL;
365		365
366	if (tty_line >= 0 && tty_line < p->num && p->ops &&	366	if (tty_line >= 0 && tty_line < p->num && p->ops &&
367	p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {	367	p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
368	res = tty_driver_kref_get(p);	368	res = tty_driver_kref_get(p);
369	*line = tty_line;	369	*line = tty_line;
370	break;	370	break;
371	}	371	}
372	}	372	}
373	mutex_unlock(&tty_mutex);	373	mutex_unlock(&tty_mutex);
374		374
375	return res;	375	return res;
376	}	376	}
377	EXPORT_SYMBOL_GPL(tty_find_polling_driver);	377	EXPORT_SYMBOL_GPL(tty_find_polling_driver);
378	#endif	378	#endif
379		379
380	/**	380	/**
381	* tty_check_change - check for POSIX terminal changes	381	* tty_check_change - check for POSIX terminal changes
382	* @tty: tty to check	382	* @tty: tty to check
383	*	383	*
384	* If we try to write to, or set the state of, a terminal and we're	384	* If we try to write to, or set the state of, a terminal and we're
385	* not in the foreground, send a SIGTTOU. If the signal is blocked or	385	* not in the foreground, send a SIGTTOU. If the signal is blocked or
386	* ignored, go ahead and perform the operation. (POSIX 7.2)	386	* ignored, go ahead and perform the operation. (POSIX 7.2)
387	*	387	*
388	* Locking: ctrl_lock	388	* Locking: ctrl_lock
389	*/	389	*/
390		390
391	int tty_check_change(struct tty_struct *tty)	391	int tty_check_change(struct tty_struct *tty)
392	{	392	{
393	unsigned long flags;	393	unsigned long flags;
394	int ret = 0;	394	int ret = 0;
395		395
396	if (current->signal->tty != tty)	396	if (current->signal->tty != tty)
397	return 0;	397	return 0;
398		398
399	spin_lock_irqsave(&tty->ctrl_lock, flags);	399	spin_lock_irqsave(&tty->ctrl_lock, flags);
400		400
401	if (!tty->pgrp) {	401	if (!tty->pgrp) {
402	printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");	402	printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
403	goto out_unlock;	403	goto out_unlock;
404	}	404	}
405	if (task_pgrp(current) == tty->pgrp)	405	if (task_pgrp(current) == tty->pgrp)
406	goto out_unlock;	406	goto out_unlock;
407	spin_unlock_irqrestore(&tty->ctrl_lock, flags);	407	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
408	if (is_ignored(SIGTTOU))	408	if (is_ignored(SIGTTOU))
409	goto out;	409	goto out;
410	if (is_current_pgrp_orphaned()) {	410	if (is_current_pgrp_orphaned()) {
411	ret = -EIO;	411	ret = -EIO;
412	goto out;	412	goto out;
413	}	413	}
414	kill_pgrp(task_pgrp(current), SIGTTOU, 1);	414	kill_pgrp(task_pgrp(current), SIGTTOU, 1);
415	set_thread_flag(TIF_SIGPENDING);	415	set_thread_flag(TIF_SIGPENDING);
416	ret = -ERESTARTSYS;	416	ret = -ERESTARTSYS;
417	out:	417	out:
418	return ret;	418	return ret;
419	out_unlock:	419	out_unlock:
420	spin_unlock_irqrestore(&tty->ctrl_lock, flags);	420	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
421	return ret;	421	return ret;
422	}	422	}
423		423
424	EXPORT_SYMBOL(tty_check_change);	424	EXPORT_SYMBOL(tty_check_change);
425		425
426	static ssize_t hung_up_tty_read(struct file file, char __user buf,	426	static ssize_t hung_up_tty_read(struct file file, char __user buf,
427	size_t count, loff_t *ppos)	427	size_t count, loff_t *ppos)
428	{	428	{
429	return 0;	429	return 0;
430	}	430	}
431		431
432	static ssize_t hung_up_tty_write(struct file file, const char __user buf,	432	static ssize_t hung_up_tty_write(struct file file, const char __user buf,
433	size_t count, loff_t *ppos)	433	size_t count, loff_t *ppos)
434	{	434	{
435	return -EIO;	435	return -EIO;
436	}	436	}
437		437
438	/* No kernel lock held - none needed ;) */	438	/* No kernel lock held - none needed ;) */
439	static unsigned int hung_up_tty_poll(struct file filp, poll_table wait)	439	static unsigned int hung_up_tty_poll(struct file filp, poll_table wait)
440	{	440	{
441	return POLLIN \| POLLOUT \| POLLERR \| POLLHUP \| POLLRDNORM \| POLLWRNORM;	441	return POLLIN \| POLLOUT \| POLLERR \| POLLHUP \| POLLRDNORM \| POLLWRNORM;
442	}	442	}
443		443
444	static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,	444	static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
445	unsigned long arg)	445	unsigned long arg)
446	{	446	{
447	return cmd == TIOCSPGRP ? -ENOTTY : -EIO;	447	return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
448	}	448	}
449		449
450	static long hung_up_tty_compat_ioctl(struct file *file,	450	static long hung_up_tty_compat_ioctl(struct file *file,
451	unsigned int cmd, unsigned long arg)	451	unsigned int cmd, unsigned long arg)
452	{	452	{
453	return cmd == TIOCSPGRP ? -ENOTTY : -EIO;	453	return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
454	}	454	}
455		455
456	static const struct file_operations tty_fops = {	456	static const struct file_operations tty_fops = {
457	.llseek = no_llseek,	457	.llseek = no_llseek,
458	.read = tty_read,	458	.read = tty_read,
459	.write = tty_write,	459	.write = tty_write,
460	.poll = tty_poll,	460	.poll = tty_poll,
461	.unlocked_ioctl = tty_ioctl,	461	.unlocked_ioctl = tty_ioctl,
462	.compat_ioctl = tty_compat_ioctl,	462	.compat_ioctl = tty_compat_ioctl,
463	.open = tty_open,	463	.open = tty_open,
464	.release = tty_release,	464	.release = tty_release,
465	.fasync = tty_fasync,	465	.fasync = tty_fasync,
466	};	466	};
467		467
468	static const struct file_operations console_fops = {	468	static const struct file_operations console_fops = {
469	.llseek = no_llseek,	469	.llseek = no_llseek,
470	.read = tty_read,	470	.read = tty_read,
471	.write = redirected_tty_write,	471	.write = redirected_tty_write,
472	.poll = tty_poll,	472	.poll = tty_poll,
473	.unlocked_ioctl = tty_ioctl,	473	.unlocked_ioctl = tty_ioctl,
474	.compat_ioctl = tty_compat_ioctl,	474	.compat_ioctl = tty_compat_ioctl,
475	.open = tty_open,	475	.open = tty_open,
476	.release = tty_release,	476	.release = tty_release,
477	.fasync = tty_fasync,	477	.fasync = tty_fasync,
478	};	478	};
479		479
480	static const struct file_operations hung_up_tty_fops = {	480	static const struct file_operations hung_up_tty_fops = {
481	.llseek = no_llseek,	481	.llseek = no_llseek,
482	.read = hung_up_tty_read,	482	.read = hung_up_tty_read,
483	.write = hung_up_tty_write,	483	.write = hung_up_tty_write,
484	.poll = hung_up_tty_poll,	484	.poll = hung_up_tty_poll,
485	.unlocked_ioctl = hung_up_tty_ioctl,	485	.unlocked_ioctl = hung_up_tty_ioctl,
486	.compat_ioctl = hung_up_tty_compat_ioctl,	486	.compat_ioctl = hung_up_tty_compat_ioctl,
487	.release = tty_release,	487	.release = tty_release,
488	};	488	};
489		489
490	static DEFINE_SPINLOCK(redirect_lock);	490	static DEFINE_SPINLOCK(redirect_lock);
491	static struct file *redirect;	491	static struct file *redirect;
492		492
493		493
494	void proc_clear_tty(struct task_struct *p)	494	void proc_clear_tty(struct task_struct *p)
495	{	495	{
496	unsigned long flags;	496	unsigned long flags;
497	struct tty_struct *tty;	497	struct tty_struct *tty;
498	spin_lock_irqsave(&p->sighand->siglock, flags);	498	spin_lock_irqsave(&p->sighand->siglock, flags);
499	tty = p->signal->tty;	499	tty = p->signal->tty;
500	p->signal->tty = NULL;	500	p->signal->tty = NULL;
501	spin_unlock_irqrestore(&p->sighand->siglock, flags);	501	spin_unlock_irqrestore(&p->sighand->siglock, flags);
502	tty_kref_put(tty);	502	tty_kref_put(tty);
503	}	503	}
504		504
505	/**	505	/**
506	* proc_set_tty - set the controlling terminal	506	* proc_set_tty - set the controlling terminal
507	*	507	*
508	* Only callable by the session leader and only if it does not already have	508	* Only callable by the session leader and only if it does not already have
509	* a controlling terminal.	509	* a controlling terminal.
510	*	510	*
511	* Caller must hold: tty_lock()	511	* Caller must hold: tty_lock()
512	* a readlock on tasklist_lock	512	* a readlock on tasklist_lock
513	* sighand lock	513	* sighand lock
514	*/	514	*/
515	static void __proc_set_tty(struct tty_struct *tty)	515	static void __proc_set_tty(struct tty_struct *tty)
516	{	516	{
517	unsigned long flags;	517	unsigned long flags;
518		518
519	spin_lock_irqsave(&tty->ctrl_lock, flags);	519	spin_lock_irqsave(&tty->ctrl_lock, flags);
520	/*	520	/*
521	* The session and fg pgrp references will be non-NULL if	521	* The session and fg pgrp references will be non-NULL if
522	* tiocsctty() is stealing the controlling tty	522	* tiocsctty() is stealing the controlling tty
523	*/	523	*/
524	put_pid(tty->session);	524	put_pid(tty->session);
525	put_pid(tty->pgrp);	525	put_pid(tty->pgrp);
526	tty->pgrp = get_pid(task_pgrp(current));	526	tty->pgrp = get_pid(task_pgrp(current));
527	spin_unlock_irqrestore(&tty->ctrl_lock, flags);	527	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
528	tty->session = get_pid(task_session(current));	528	tty->session = get_pid(task_session(current));
529	if (current->signal->tty) {	529	if (current->signal->tty) {
530	printk(KERN_DEBUG "tty not NULL!!\n");	530	printk(KERN_DEBUG "tty not NULL!!\n");
531	tty_kref_put(current->signal->tty);	531	tty_kref_put(current->signal->tty);
532	}	532	}
533	put_pid(current->signal->tty_old_pgrp);	533	put_pid(current->signal->tty_old_pgrp);
534	current->signal->tty = tty_kref_get(tty);	534	current->signal->tty = tty_kref_get(tty);
535	current->signal->tty_old_pgrp = NULL;	535	current->signal->tty_old_pgrp = NULL;
536	}	536	}
537		537
538	static void proc_set_tty(struct tty_struct *tty)	538	static void proc_set_tty(struct tty_struct *tty)
539	{	539	{
540	spin_lock_irq(&current->sighand->siglock);	540	spin_lock_irq(&current->sighand->siglock);
541	__proc_set_tty(tty);	541	__proc_set_tty(tty);
542	spin_unlock_irq(&current->sighand->siglock);	542	spin_unlock_irq(&current->sighand->siglock);
543	}	543	}
544		544
545	struct tty_struct *get_current_tty(void)	545	struct tty_struct *get_current_tty(void)
546	{	546	{
547	struct tty_struct *tty;	547	struct tty_struct *tty;
548	unsigned long flags;	548	unsigned long flags;
549		549
550	spin_lock_irqsave(&current->sighand->siglock, flags);	550	spin_lock_irqsave(&current->sighand->siglock, flags);
551	tty = tty_kref_get(current->signal->tty);	551	tty = tty_kref_get(current->signal->tty);
552	spin_unlock_irqrestore(&current->sighand->siglock, flags);	552	spin_unlock_irqrestore(&current->sighand->siglock, flags);
553	return tty;	553	return tty;
554	}	554	}
555	EXPORT_SYMBOL_GPL(get_current_tty);	555	EXPORT_SYMBOL_GPL(get_current_tty);
556		556
557	static void session_clear_tty(struct pid *session)	557	static void session_clear_tty(struct pid *session)
558	{	558	{
559	struct task_struct *p;	559	struct task_struct *p;
560	do_each_pid_task(session, PIDTYPE_SID, p) {	560	do_each_pid_task(session, PIDTYPE_SID, p) {
561	proc_clear_tty(p);	561	proc_clear_tty(p);
562	} while_each_pid_task(session, PIDTYPE_SID, p);	562	} while_each_pid_task(session, PIDTYPE_SID, p);
563	}	563	}
564		564
565	/**	565	/**
566	* tty_wakeup - request more data	566	* tty_wakeup - request more data
567	* @tty: terminal	567	* @tty: terminal
568	*	568	*
569	* Internal and external helper for wakeups of tty. This function	569	* Internal and external helper for wakeups of tty. This function
570	* informs the line discipline if present that the driver is ready	570	* informs the line discipline if present that the driver is ready
571	* to receive more output data.	571	* to receive more output data.
572	*/	572	*/
573		573
574	void tty_wakeup(struct tty_struct *tty)	574	void tty_wakeup(struct tty_struct *tty)
575	{	575	{
576	struct tty_ldisc *ld;	576	struct tty_ldisc *ld;
577		577
578	if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {	578	if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
579	ld = tty_ldisc_ref(tty);	579	ld = tty_ldisc_ref(tty);
580	if (ld) {	580	if (ld) {
581	if (ld->ops->write_wakeup)	581	if (ld->ops->write_wakeup)
582	ld->ops->write_wakeup(tty);	582	ld->ops->write_wakeup(tty);
583	tty_ldisc_deref(ld);	583	tty_ldisc_deref(ld);
584	}	584	}
585	}	585	}
586	wake_up_interruptible_poll(&tty->write_wait, POLLOUT);	586	wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
587	}	587	}
588		588
589	EXPORT_SYMBOL_GPL(tty_wakeup);	589	EXPORT_SYMBOL_GPL(tty_wakeup);
590		590
591	/**	591	/**
592	* tty_signal_session_leader - sends SIGHUP to session leader	592	* tty_signal_session_leader - sends SIGHUP to session leader
593	* @tty controlling tty	593	* @tty controlling tty
594	* @exit_session if non-zero, signal all foreground group processes	594	* @exit_session if non-zero, signal all foreground group processes
595	*	595	*
596	* Send SIGHUP and SIGCONT to the session leader and its process group.	596	* Send SIGHUP and SIGCONT to the session leader and its process group.
597	* Optionally, signal all processes in the foreground process group.	597	* Optionally, signal all processes in the foreground process group.
598	*	598	*
599	* Returns the number of processes in the session with this tty	599	* Returns the number of processes in the session with this tty
600	* as their controlling terminal. This value is used to drop	600	* as their controlling terminal. This value is used to drop
601	* tty references for those processes.	601	* tty references for those processes.
602	*/	602	*/
603	static int tty_signal_session_leader(struct tty_struct *tty, int exit_session)	603	static int tty_signal_session_leader(struct tty_struct *tty, int exit_session)
604	{	604	{
605	struct task_struct *p;	605	struct task_struct *p;
606	int refs = 0;	606	int refs = 0;
607	struct pid *tty_pgrp = NULL;	607	struct pid *tty_pgrp = NULL;
608		608
609	read_lock(&tasklist_lock);	609	read_lock(&tasklist_lock);
610	if (tty->session) {	610	if (tty->session) {
611	do_each_pid_task(tty->session, PIDTYPE_SID, p) {	611	do_each_pid_task(tty->session, PIDTYPE_SID, p) {
612	spin_lock_irq(&p->sighand->siglock);	612	spin_lock_irq(&p->sighand->siglock);
613	if (p->signal->tty == tty) {	613	if (p->signal->tty == tty) {
614	p->signal->tty = NULL;	614	p->signal->tty = NULL;
615	/* We defer the dereferences outside fo	615	/* We defer the dereferences outside fo
616	the tasklist lock */	616	the tasklist lock */
617	refs++;	617	refs++;
618	}	618	}
619	if (!p->signal->leader) {	619	if (!p->signal->leader) {
620	spin_unlock_irq(&p->sighand->siglock);	620	spin_unlock_irq(&p->sighand->siglock);
621	continue;	621	continue;
622	}	622	}
623	__group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);	623	__group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
624	__group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);	624	__group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
625	put_pid(p->signal->tty_old_pgrp); /* A noop */	625	put_pid(p->signal->tty_old_pgrp); /* A noop */
626	spin_lock(&tty->ctrl_lock);	626	spin_lock(&tty->ctrl_lock);
627	tty_pgrp = get_pid(tty->pgrp);	627	tty_pgrp = get_pid(tty->pgrp);
628	if (tty->pgrp)	628	if (tty->pgrp)
629	p->signal->tty_old_pgrp = get_pid(tty->pgrp);	629	p->signal->tty_old_pgrp = get_pid(tty->pgrp);
630	spin_unlock(&tty->ctrl_lock);	630	spin_unlock(&tty->ctrl_lock);
631	spin_unlock_irq(&p->sighand->siglock);	631	spin_unlock_irq(&p->sighand->siglock);
632	} while_each_pid_task(tty->session, PIDTYPE_SID, p);	632	} while_each_pid_task(tty->session, PIDTYPE_SID, p);
633	}	633	}
634	read_unlock(&tasklist_lock);	634	read_unlock(&tasklist_lock);
635		635
636	if (tty_pgrp) {	636	if (tty_pgrp) {
637	if (exit_session)	637	if (exit_session)
638	kill_pgrp(tty_pgrp, SIGHUP, exit_session);	638	kill_pgrp(tty_pgrp, SIGHUP, exit_session);
639	put_pid(tty_pgrp);	639	put_pid(tty_pgrp);
640	}	640	}
641		641
642	return refs;	642	return refs;
643	}	643	}
644		644
645	/**	645	/**
646	* __tty_hangup - actual handler for hangup events	646	* __tty_hangup - actual handler for hangup events
647	* @work: tty device	647	* @work: tty device
648	*	648	*
649	* This can be called by a "kworker" kernel thread. That is process	649	* This can be called by a "kworker" kernel thread. That is process
650	* synchronous but doesn't hold any locks, so we need to make sure we	650	* synchronous but doesn't hold any locks, so we need to make sure we
651	* have the appropriate locks for what we're doing.	651	* have the appropriate locks for what we're doing.
652	*	652	*
653	* The hangup event clears any pending redirections onto the hung up	653	* The hangup event clears any pending redirections onto the hung up
654	* device. It ensures future writes will error and it does the needed	654	* device. It ensures future writes will error and it does the needed
655	* line discipline hangup and signal delivery. The tty object itself	655	* line discipline hangup and signal delivery. The tty object itself
656	* remains intact.	656	* remains intact.
657	*	657	*
658	* Locking:	658	* Locking:
659	* BTM	659	* BTM
660	* redirect lock for undoing redirection	660	* redirect lock for undoing redirection
661	* file list lock for manipulating list of ttys	661	* file list lock for manipulating list of ttys
662	* tty_ldiscs_lock from called functions	662	* tty_ldiscs_lock from called functions
663	* termios_rwsem resetting termios data	663	* termios_rwsem resetting termios data
664	* tasklist_lock to walk task list for hangup event	664	* tasklist_lock to walk task list for hangup event
665	* ->siglock to protect ->signal/->sighand	665	* ->siglock to protect ->signal/->sighand
666	*/	666	*/
667	static void __tty_hangup(struct tty_struct *tty, int exit_session)	667	static void __tty_hangup(struct tty_struct *tty, int exit_session)
668	{	668	{
669	struct file *cons_filp = NULL;	669	struct file *cons_filp = NULL;
670	struct file filp, f = NULL;	670	struct file filp, f = NULL;
671	struct tty_file_private *priv;	671	struct tty_file_private *priv;
672	int closecount = 0, n;	672	int closecount = 0, n;
673	int refs;	673	int refs;
674		674
675	if (!tty)	675	if (!tty)
676	return;	676	return;
677		677
678		678
679	spin_lock(&redirect_lock);	679	spin_lock(&redirect_lock);
680	if (redirect && file_tty(redirect) == tty) {	680	if (redirect && file_tty(redirect) == tty) {
681	f = redirect;	681	f = redirect;
682	redirect = NULL;	682	redirect = NULL;
683	}	683	}
684	spin_unlock(&redirect_lock);	684	spin_unlock(&redirect_lock);
685		685
686	tty_lock(tty);	686	tty_lock(tty);
687		687
688	if (test_bit(TTY_HUPPED, &tty->flags)) {	688	if (test_bit(TTY_HUPPED, &tty->flags)) {
689	tty_unlock(tty);	689	tty_unlock(tty);
690	return;	690	return;
691	}	691	}
692		692
693	/* inuse_filps is protected by the single tty lock,	693	/* inuse_filps is protected by the single tty lock,
694	this really needs to change if we want to flush the	694	this really needs to change if we want to flush the
695	workqueue with the lock held */	695	workqueue with the lock held */
696	check_tty_count(tty, "tty_hangup");	696	check_tty_count(tty, "tty_hangup");
697		697
698	spin_lock(&tty_files_lock);	698	spin_lock(&tty_files_lock);
699	/* This breaks for file handles being sent over AF_UNIX sockets ? */	699	/* This breaks for file handles being sent over AF_UNIX sockets ? */
700	list_for_each_entry(priv, &tty->tty_files, list) {	700	list_for_each_entry(priv, &tty->tty_files, list) {
701	filp = priv->file;	701	filp = priv->file;
702	if (filp->f_op->write == redirected_tty_write)	702	if (filp->f_op->write == redirected_tty_write)
703	cons_filp = filp;	703	cons_filp = filp;
704	if (filp->f_op->write != tty_write)	704	if (filp->f_op->write != tty_write)
705	continue;	705	continue;
706	closecount++;	706	closecount++;
707	__tty_fasync(-1, filp, 0); /* can't block */	707	__tty_fasync(-1, filp, 0); /* can't block */
708	filp->f_op = &hung_up_tty_fops;	708	filp->f_op = &hung_up_tty_fops;
709	}	709	}
710	spin_unlock(&tty_files_lock);	710	spin_unlock(&tty_files_lock);
711		711
712	refs = tty_signal_session_leader(tty, exit_session);	712	refs = tty_signal_session_leader(tty, exit_session);
713	/* Account for the p->signal references we killed */	713	/* Account for the p->signal references we killed */
714	while (refs--)	714	while (refs--)
715	tty_kref_put(tty);	715	tty_kref_put(tty);
716		716
717	tty_ldisc_hangup(tty);	717	tty_ldisc_hangup(tty);
718		718
719	spin_lock_irq(&tty->ctrl_lock);	719	spin_lock_irq(&tty->ctrl_lock);
720	clear_bit(TTY_THROTTLED, &tty->flags);	720	clear_bit(TTY_THROTTLED, &tty->flags);
721	clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);	721	clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
722	put_pid(tty->session);	722	put_pid(tty->session);
723	put_pid(tty->pgrp);	723	put_pid(tty->pgrp);
724	tty->session = NULL;	724	tty->session = NULL;
725	tty->pgrp = NULL;	725	tty->pgrp = NULL;
726	tty->ctrl_status = 0;	726	tty->ctrl_status = 0;
727	spin_unlock_irq(&tty->ctrl_lock);	727	spin_unlock_irq(&tty->ctrl_lock);
728		728
729	/*	729	/*
730	* If one of the devices matches a console pointer, we	730	* If one of the devices matches a console pointer, we
731	* cannot just call hangup() because that will cause	731	* cannot just call hangup() because that will cause
732	* tty->count and state->count to go out of sync.	732	* tty->count and state->count to go out of sync.
733	* So we just call close() the right number of times.	733	* So we just call close() the right number of times.
734	*/	734	*/
735	if (cons_filp) {	735	if (cons_filp) {
736	if (tty->ops->close)	736	if (tty->ops->close)
737	for (n = 0; n < closecount; n++)	737	for (n = 0; n < closecount; n++)
738	tty->ops->close(tty, cons_filp);	738	tty->ops->close(tty, cons_filp);
739	} else if (tty->ops->hangup)	739	} else if (tty->ops->hangup)
740	tty->ops->hangup(tty);	740	tty->ops->hangup(tty);
741	/*	741	/*
742	* We don't want to have driver/ldisc interactions beyond	742	* We don't want to have driver/ldisc interactions beyond
743	* the ones we did here. The driver layer expects no	743	* the ones we did here. The driver layer expects no
744	* calls after ->hangup() from the ldisc side. However we	744	* calls after ->hangup() from the ldisc side. However we
745	* can't yet guarantee all that.	745	* can't yet guarantee all that.
746	*/	746	*/
747	set_bit(TTY_HUPPED, &tty->flags);	747	set_bit(TTY_HUPPED, &tty->flags);
748	tty_unlock(tty);	748	tty_unlock(tty);
749		749
750	if (f)	750	if (f)
751	fput(f);	751	fput(f);
752	}	752	}
753		753
754	static void do_tty_hangup(struct work_struct *work)	754	static void do_tty_hangup(struct work_struct *work)
755	{	755	{
756	struct tty_struct *tty =	756	struct tty_struct *tty =
757	container_of(work, struct tty_struct, hangup_work);	757	container_of(work, struct tty_struct, hangup_work);
758		758
759	__tty_hangup(tty, 0);	759	__tty_hangup(tty, 0);
760	}	760	}
761		761
762	/**	762	/**
763	* tty_hangup - trigger a hangup event	763	* tty_hangup - trigger a hangup event
764	* @tty: tty to hangup	764	* @tty: tty to hangup
765	*	765	*
766	* A carrier loss (virtual or otherwise) has occurred on this like	766	* A carrier loss (virtual or otherwise) has occurred on this like
767	* schedule a hangup sequence to run after this event.	767	* schedule a hangup sequence to run after this event.
768	*/	768	*/
769		769
770	void tty_hangup(struct tty_struct *tty)	770	void tty_hangup(struct tty_struct *tty)
771	{	771	{
772	#ifdef TTY_DEBUG_HANGUP	772	#ifdef TTY_DEBUG_HANGUP
773	char buf[64];	773	char buf[64];
774	printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));	774	printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
775	#endif	775	#endif
776	schedule_work(&tty->hangup_work);	776	schedule_work(&tty->hangup_work);
777	}	777	}
778		778
779	EXPORT_SYMBOL(tty_hangup);	779	EXPORT_SYMBOL(tty_hangup);
780		780
781	/**	781	/**
782	* tty_vhangup - process vhangup	782	* tty_vhangup - process vhangup
783	* @tty: tty to hangup	783	* @tty: tty to hangup
784	*	784	*
785	* The user has asked via system call for the terminal to be hung up.	785	* The user has asked via system call for the terminal to be hung up.
786	* We do this synchronously so that when the syscall returns the process	786	* We do this synchronously so that when the syscall returns the process
787	* is complete. That guarantee is necessary for security reasons.	787	* is complete. That guarantee is necessary for security reasons.
788	*/	788	*/
789		789
790	void tty_vhangup(struct tty_struct *tty)	790	void tty_vhangup(struct tty_struct *tty)
791	{	791	{
792	#ifdef TTY_DEBUG_HANGUP	792	#ifdef TTY_DEBUG_HANGUP
793	char buf[64];	793	char buf[64];
794		794
795	printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));	795	printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
796	#endif	796	#endif
797	__tty_hangup(tty, 0);	797	__tty_hangup(tty, 0);
798	}	798	}
799		799
800	EXPORT_SYMBOL(tty_vhangup);	800	EXPORT_SYMBOL(tty_vhangup);
801		801
802		802
803	/**	803	/**
804	* tty_vhangup_self - process vhangup for own ctty	804	* tty_vhangup_self - process vhangup for own ctty
805	*	805	*
806	* Perform a vhangup on the current controlling tty	806	* Perform a vhangup on the current controlling tty
807	*/	807	*/
808		808
809	void tty_vhangup_self(void)	809	void tty_vhangup_self(void)
810	{	810	{
811	struct tty_struct *tty;	811	struct tty_struct *tty;
812		812
813	tty = get_current_tty();	813	tty = get_current_tty();
814	if (tty) {	814	if (tty) {
815	tty_vhangup(tty);	815	tty_vhangup(tty);
816	tty_kref_put(tty);	816	tty_kref_put(tty);
817	}	817	}
818	}	818	}
819		819
820	/**	820	/**
821	* tty_vhangup_session - hangup session leader exit	821	* tty_vhangup_session - hangup session leader exit
822	* @tty: tty to hangup	822	* @tty: tty to hangup
823	*	823	*
824	* The session leader is exiting and hanging up its controlling terminal.	824	* The session leader is exiting and hanging up its controlling terminal.
825	* Every process in the foreground process group is signalled SIGHUP.	825	* Every process in the foreground process group is signalled SIGHUP.
826	*	826	*
827	* We do this synchronously so that when the syscall returns the process	827	* We do this synchronously so that when the syscall returns the process
828	* is complete. That guarantee is necessary for security reasons.	828	* is complete. That guarantee is necessary for security reasons.
829	*/	829	*/
830		830
831	static void tty_vhangup_session(struct tty_struct *tty)	831	static void tty_vhangup_session(struct tty_struct *tty)
832	{	832	{
833	#ifdef TTY_DEBUG_HANGUP	833	#ifdef TTY_DEBUG_HANGUP
834	char buf[64];	834	char buf[64];
835		835
836	printk(KERN_DEBUG "%s vhangup session...\n", tty_name(tty, buf));	836	printk(KERN_DEBUG "%s vhangup session...\n", tty_name(tty, buf));
837	#endif	837	#endif
838	__tty_hangup(tty, 1);	838	__tty_hangup(tty, 1);
839	}	839	}
840		840
841	/**	841	/**
842	* tty_hung_up_p - was tty hung up	842	* tty_hung_up_p - was tty hung up
843	* @filp: file pointer of tty	843	* @filp: file pointer of tty
844	*	844	*
845	* Return true if the tty has been subject to a vhangup or a carrier	845	* Return true if the tty has been subject to a vhangup or a carrier
846	* loss	846	* loss
847	*/	847	*/
848		848
849	int tty_hung_up_p(struct file *filp)	849	int tty_hung_up_p(struct file *filp)
850	{	850	{
851	return (filp->f_op == &hung_up_tty_fops);	851	return (filp->f_op == &hung_up_tty_fops);
852	}	852	}
853		853
854	EXPORT_SYMBOL(tty_hung_up_p);	854	EXPORT_SYMBOL(tty_hung_up_p);
855		855
856	/**	856	/**
857	* disassociate_ctty - disconnect controlling tty	857	* disassociate_ctty - disconnect controlling tty
858	* @on_exit: true if exiting so need to "hang up" the session	858	* @on_exit: true if exiting so need to "hang up" the session
859	*	859	*
860	* This function is typically called only by the session leader, when	860	* This function is typically called only by the session leader, when
861	* it wants to disassociate itself from its controlling tty.	861	* it wants to disassociate itself from its controlling tty.
862	*	862	*
863	* It performs the following functions:	863	* It performs the following functions:
864	* (1) Sends a SIGHUP and SIGCONT to the foreground process group	864	* (1) Sends a SIGHUP and SIGCONT to the foreground process group
865	* (2) Clears the tty from being controlling the session	865	* (2) Clears the tty from being controlling the session
866	* (3) Clears the controlling tty for all processes in the	866	* (3) Clears the controlling tty for all processes in the
867	* session group.	867	* session group.
868	*	868	*
869	* The argument on_exit is set to 1 if called when a process is	869	* The argument on_exit is set to 1 if called when a process is
870	* exiting; it is 0 if called by the ioctl TIOCNOTTY.	870	* exiting; it is 0 if called by the ioctl TIOCNOTTY.
871	*	871	*
872	* Locking:	872	* Locking:
873	* BTM is taken for hysterical raisins, and held when	873	* BTM is taken for hysterical raisins, and held when
874	* called from no_tty().	874	* called from no_tty().
875	* tty_mutex is taken to protect tty	875	* tty_mutex is taken to protect tty
876	* ->siglock is taken to protect ->signal/->sighand	876	* ->siglock is taken to protect ->signal/->sighand
877	* tasklist_lock is taken to walk process list for sessions	877	* tasklist_lock is taken to walk process list for sessions
878	* ->siglock is taken to protect ->signal/->sighand	878	* ->siglock is taken to protect ->signal/->sighand
879	*/	879	*/
880		880
881	void disassociate_ctty(int on_exit)	881	void disassociate_ctty(int on_exit)
882	{	882	{
883	struct tty_struct *tty;	883	struct tty_struct *tty;
884		884
885	if (!current->signal->leader)	885	if (!current->signal->leader)
886	return;	886	return;
887		887
888	tty = get_current_tty();	888	tty = get_current_tty();
889	if (tty) {	889	if (tty) {
890	if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY) {	890	if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY) {
891	tty_vhangup_session(tty);	891	tty_vhangup_session(tty);
892	} else {	892	} else {
893	struct pid *tty_pgrp = tty_get_pgrp(tty);	893	struct pid *tty_pgrp = tty_get_pgrp(tty);
894	if (tty_pgrp) {	894	if (tty_pgrp) {
895	kill_pgrp(tty_pgrp, SIGHUP, on_exit);	895	kill_pgrp(tty_pgrp, SIGHUP, on_exit);
896	if (!on_exit)	896	if (!on_exit)
897	kill_pgrp(tty_pgrp, SIGCONT, on_exit);	897	kill_pgrp(tty_pgrp, SIGCONT, on_exit);
898	put_pid(tty_pgrp);	898	put_pid(tty_pgrp);
899	}	899	}
900	}	900	}
901	tty_kref_put(tty);	901	tty_kref_put(tty);
902		902
903	} else if (on_exit) {	903	} else if (on_exit) {
904	struct pid *old_pgrp;	904	struct pid *old_pgrp;
905	spin_lock_irq(&current->sighand->siglock);	905	spin_lock_irq(&current->sighand->siglock);
906	old_pgrp = current->signal->tty_old_pgrp;	906	old_pgrp = current->signal->tty_old_pgrp;
907	current->signal->tty_old_pgrp = NULL;	907	current->signal->tty_old_pgrp = NULL;
908	spin_unlock_irq(&current->sighand->siglock);	908	spin_unlock_irq(&current->sighand->siglock);
909	if (old_pgrp) {	909	if (old_pgrp) {
910	kill_pgrp(old_pgrp, SIGHUP, on_exit);	910	kill_pgrp(old_pgrp, SIGHUP, on_exit);
911	kill_pgrp(old_pgrp, SIGCONT, on_exit);	911	kill_pgrp(old_pgrp, SIGCONT, on_exit);
912	put_pid(old_pgrp);	912	put_pid(old_pgrp);
913	}	913	}
914	return;	914	return;
915	}	915	}
916		916
917	spin_lock_irq(&current->sighand->siglock);	917	spin_lock_irq(&current->sighand->siglock);
918	put_pid(current->signal->tty_old_pgrp);	918	put_pid(current->signal->tty_old_pgrp);
919	current->signal->tty_old_pgrp = NULL;	919	current->signal->tty_old_pgrp = NULL;
920		920
921	tty = tty_kref_get(current->signal->tty);	921	tty = tty_kref_get(current->signal->tty);
922	if (tty) {	922	if (tty) {
923	unsigned long flags;	923	unsigned long flags;
924	spin_lock_irqsave(&tty->ctrl_lock, flags);	924	spin_lock_irqsave(&tty->ctrl_lock, flags);
925	put_pid(tty->session);	925	put_pid(tty->session);
926	put_pid(tty->pgrp);	926	put_pid(tty->pgrp);
927	tty->session = NULL;	927	tty->session = NULL;
928	tty->pgrp = NULL;	928	tty->pgrp = NULL;
929	spin_unlock_irqrestore(&tty->ctrl_lock, flags);	929	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
930	tty_kref_put(tty);	930	tty_kref_put(tty);
931	} else {	931	} else {
932	#ifdef TTY_DEBUG_HANGUP	932	#ifdef TTY_DEBUG_HANGUP
933	printk(KERN_DEBUG "error attempted to write to tty [0x%p]"	933	printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
934	" = NULL", tty);	934	" = NULL", tty);
935	#endif	935	#endif
936	}	936	}
937		937
938	spin_unlock_irq(&current->sighand->siglock);	938	spin_unlock_irq(&current->sighand->siglock);
939	/* Now clear signal->tty under the lock */	939	/* Now clear signal->tty under the lock */
940	read_lock(&tasklist_lock);	940	read_lock(&tasklist_lock);
941	session_clear_tty(task_session(current));	941	session_clear_tty(task_session(current));
942	read_unlock(&tasklist_lock);	942	read_unlock(&tasklist_lock);
943	}	943	}
944		944
945	/**	945	/**
946	*	946	*
947	* no_tty - Ensure the current process does not have a controlling tty	947	* no_tty - Ensure the current process does not have a controlling tty
948	*/	948	*/
949	void no_tty(void)	949	void no_tty(void)
950	{	950	{
951	/* FIXME: Review locking here. The tty_lock never covered any race	951	/* FIXME: Review locking here. The tty_lock never covered any race
952	between a new association and proc_clear_tty but possible we need	952	between a new association and proc_clear_tty but possible we need
953	to protect against this anyway */	953	to protect against this anyway */
954	struct task_struct *tsk = current;	954	struct task_struct *tsk = current;
955	disassociate_ctty(0);	955	disassociate_ctty(0);
956	proc_clear_tty(tsk);	956	proc_clear_tty(tsk);
957	}	957	}
958		958
959		959
960	/**	960	/**
961	* stop_tty - propagate flow control	961	* stop_tty - propagate flow control
962	* @tty: tty to stop	962	* @tty: tty to stop
963	*	963	*
964	* Perform flow control to the driver. May be called	964	* Perform flow control to the driver. May be called
965	* on an already stopped device and will not re-call the driver	965	* on an already stopped device and will not re-call the driver
966	* method.	966	* method.
967	*	967	*
968	* This functionality is used by both the line disciplines for	968	* This functionality is used by both the line disciplines for
969	* halting incoming flow and by the driver. It may therefore be	969	* halting incoming flow and by the driver. It may therefore be
970	* called from any context, may be under the tty atomic_write_lock	970	* called from any context, may be under the tty atomic_write_lock
971	* but not always.	971	* but not always.
972	*	972	*
973	* Locking:	973	* Locking:
974	* flow_lock	974	* flow_lock
975	*/	975	*/
976		976
977	void __stop_tty(struct tty_struct *tty)	977	void __stop_tty(struct tty_struct *tty)
978	{	978	{
979	if (tty->stopped)	979	if (tty->stopped)
980	return;	980	return;
981	tty->stopped = 1;	981	tty->stopped = 1;
982	if (tty->ops->stop)	982	if (tty->ops->stop)
983	tty->ops->stop(tty);	983	tty->ops->stop(tty);
984	}	984	}
985		985
986	void stop_tty(struct tty_struct *tty)	986	void stop_tty(struct tty_struct *tty)
987	{	987	{
988	unsigned long flags;	988	unsigned long flags;
989		989
990	spin_lock_irqsave(&tty->flow_lock, flags);	990	spin_lock_irqsave(&tty->flow_lock, flags);
991	__stop_tty(tty);	991	__stop_tty(tty);
992	spin_unlock_irqrestore(&tty->flow_lock, flags);	992	spin_unlock_irqrestore(&tty->flow_lock, flags);
993	}	993	}
994	EXPORT_SYMBOL(stop_tty);	994	EXPORT_SYMBOL(stop_tty);
995		995
996	/**	996	/**
997	* start_tty - propagate flow control	997	* start_tty - propagate flow control
998	* @tty: tty to start	998	* @tty: tty to start
999	*	999	*
1000	* Start a tty that has been stopped if at all possible. If this	1000	* Start a tty that has been stopped if at all possible. If this
1001	* tty was previous stopped and is now being started, the driver	1001	* tty was previous stopped and is now being started, the driver
1002	* start method is invoked and the line discipline woken.	1002	* start method is invoked and the line discipline woken.
1003	*	1003	*
1004	* Locking:	1004	* Locking:
1005	* flow_lock	1005	* flow_lock
1006	*/	1006	*/
1007		1007
1008	void __start_tty(struct tty_struct *tty)	1008	void __start_tty(struct tty_struct *tty)
1009	{	1009	{
1010	if (!tty->stopped \|\| tty->flow_stopped)	1010	if (!tty->stopped \|\| tty->flow_stopped)
1011	return;	1011	return;
1012	tty->stopped = 0;	1012	tty->stopped = 0;
1013	if (tty->ops->start)	1013	if (tty->ops->start)
1014	tty->ops->start(tty);	1014	tty->ops->start(tty);
1015	tty_wakeup(tty);	1015	tty_wakeup(tty);
1016	}	1016	}
1017		1017
1018	void start_tty(struct tty_struct *tty)	1018	void start_tty(struct tty_struct *tty)
1019	{	1019	{
1020	unsigned long flags;	1020	unsigned long flags;
1021		1021
1022	spin_lock_irqsave(&tty->flow_lock, flags);	1022	spin_lock_irqsave(&tty->flow_lock, flags);
1023	__start_tty(tty);	1023	__start_tty(tty);
1024	spin_unlock_irqrestore(&tty->flow_lock, flags);	1024	spin_unlock_irqrestore(&tty->flow_lock, flags);
1025	}	1025	}
1026	EXPORT_SYMBOL(start_tty);	1026	EXPORT_SYMBOL(start_tty);
1027		1027
1028	/* We limit tty time update visibility to every 8 seconds or so. */	1028	/* We limit tty time update visibility to every 8 seconds or so. */
1029	static void tty_update_time(struct timespec *time)	1029	static void tty_update_time(struct timespec *time)
1030	{	1030	{
1031	unsigned long sec = get_seconds() & ~7;	1031	unsigned long sec = get_seconds();
1032	if ((long)(sec - time->tv_sec) > 0)	1032	if (abs(sec - time->tv_sec) & ~7)
1033	time->tv_sec = sec;	1033	time->tv_sec = sec;
1034	}	1034	}
1035		1035
1036	/**	1036	/**
1037	* tty_read - read method for tty device files	1037	* tty_read - read method for tty device files
1038	* @file: pointer to tty file	1038	* @file: pointer to tty file
1039	* @buf: user buffer	1039	* @buf: user buffer
1040	* @count: size of user buffer	1040	* @count: size of user buffer
1041	* @ppos: unused	1041	* @ppos: unused
1042	*	1042	*
1043	* Perform the read system call function on this terminal device. Checks	1043	* Perform the read system call function on this terminal device. Checks
1044	* for hung up devices before calling the line discipline method.	1044	* for hung up devices before calling the line discipline method.
1045	*	1045	*
1046	* Locking:	1046	* Locking:
1047	* Locks the line discipline internally while needed. Multiple	1047	* Locks the line discipline internally while needed. Multiple
1048	* read calls may be outstanding in parallel.	1048	* read calls may be outstanding in parallel.
1049	*/	1049	*/
1050		1050
1051	static ssize_t tty_read(struct file file, char __user buf, size_t count,	1051	static ssize_t tty_read(struct file file, char __user buf, size_t count,
1052	loff_t *ppos)	1052	loff_t *ppos)
1053	{	1053	{
1054	int i;	1054	int i;
1055	struct inode *inode = file_inode(file);	1055	struct inode *inode = file_inode(file);
1056	struct tty_struct *tty = file_tty(file);	1056	struct tty_struct *tty = file_tty(file);
1057	struct tty_ldisc *ld;	1057	struct tty_ldisc *ld;
1058		1058
1059	if (tty_paranoia_check(tty, inode, "tty_read"))	1059	if (tty_paranoia_check(tty, inode, "tty_read"))
1060	return -EIO;	1060	return -EIO;
1061	if (!tty \|\| (test_bit(TTY_IO_ERROR, &tty->flags)))	1061	if (!tty \|\| (test_bit(TTY_IO_ERROR, &tty->flags)))
1062	return -EIO;	1062	return -EIO;
1063		1063
1064	/* We want to wait for the line discipline to sort out in this	1064	/* We want to wait for the line discipline to sort out in this
1065	situation */	1065	situation */
1066	ld = tty_ldisc_ref_wait(tty);	1066	ld = tty_ldisc_ref_wait(tty);
1067	if (ld->ops->read)	1067	if (ld->ops->read)
1068	i = ld->ops->read(tty, file, buf, count);	1068	i = ld->ops->read(tty, file, buf, count);
1069	else	1069	else
1070	i = -EIO;	1070	i = -EIO;
1071	tty_ldisc_deref(ld);	1071	tty_ldisc_deref(ld);
1072		1072
1073	if (i > 0)	1073	if (i > 0)
1074	tty_update_time(&inode->i_atime);	1074	tty_update_time(&inode->i_atime);
1075		1075
1076	return i;	1076	return i;
1077	}	1077	}
1078		1078
1079	static void tty_write_unlock(struct tty_struct *tty)	1079	static void tty_write_unlock(struct tty_struct *tty)
1080	{	1080	{
1081	mutex_unlock(&tty->atomic_write_lock);	1081	mutex_unlock(&tty->atomic_write_lock);
1082	wake_up_interruptible_poll(&tty->write_wait, POLLOUT);	1082	wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
1083	}	1083	}
1084		1084
1085	static int tty_write_lock(struct tty_struct *tty, int ndelay)	1085	static int tty_write_lock(struct tty_struct *tty, int ndelay)
1086	{	1086	{
1087	if (!mutex_trylock(&tty->atomic_write_lock)) {	1087	if (!mutex_trylock(&tty->atomic_write_lock)) {
1088	if (ndelay)	1088	if (ndelay)
1089	return -EAGAIN;	1089	return -EAGAIN;
1090	if (mutex_lock_interruptible(&tty->atomic_write_lock))	1090	if (mutex_lock_interruptible(&tty->atomic_write_lock))
1091	return -ERESTARTSYS;	1091	return -ERESTARTSYS;
1092	}	1092	}
1093	return 0;	1093	return 0;
1094	}	1094	}
1095		1095
1096	/*	1096	/*
1097	* Split writes up in sane blocksizes to avoid	1097	* Split writes up in sane blocksizes to avoid
1098	* denial-of-service type attacks	1098	* denial-of-service type attacks
1099	*/	1099	*/
1100	static inline ssize_t do_tty_write(	1100	static inline ssize_t do_tty_write(
1101	ssize_t (write)(struct tty_struct , struct file , const unsigned char , size_t),	1101	ssize_t (write)(struct tty_struct , struct file , const unsigned char , size_t),
1102	struct tty_struct *tty,	1102	struct tty_struct *tty,
1103	struct file *file,	1103	struct file *file,
1104	const char __user *buf,	1104	const char __user *buf,
1105	size_t count)	1105	size_t count)
1106	{	1106	{
1107	ssize_t ret, written = 0;	1107	ssize_t ret, written = 0;
1108	unsigned int chunk;	1108	unsigned int chunk;
1109		1109
1110	ret = tty_write_lock(tty, file->f_flags & O_NDELAY);	1110	ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1111	if (ret < 0)	1111	if (ret < 0)
1112	return ret;	1112	return ret;
1113		1113
1114	/*	1114	/*
1115	* We chunk up writes into a temporary buffer. This	1115	* We chunk up writes into a temporary buffer. This
1116	* simplifies low-level drivers immensely, since they	1116	* simplifies low-level drivers immensely, since they
1117	* don't have locking issues and user mode accesses.	1117	* don't have locking issues and user mode accesses.
1118	*	1118	*
1119	* But if TTY_NO_WRITE_SPLIT is set, we should use a	1119	* But if TTY_NO_WRITE_SPLIT is set, we should use a
1120	* big chunk-size..	1120	* big chunk-size..
1121	*	1121	*
1122	* The default chunk-size is 2kB, because the NTTY	1122	* The default chunk-size is 2kB, because the NTTY
1123	* layer has problems with bigger chunks. It will	1123	* layer has problems with bigger chunks. It will
1124	* claim to be able to handle more characters than	1124	* claim to be able to handle more characters than
1125	* it actually does.	1125	* it actually does.
1126	*	1126	*
1127	* FIXME: This can probably go away now except that 64K chunks	1127	* FIXME: This can probably go away now except that 64K chunks
1128	* are too likely to fail unless switched to vmalloc...	1128	* are too likely to fail unless switched to vmalloc...
1129	*/	1129	*/
1130	chunk = 2048;	1130	chunk = 2048;
1131	if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))	1131	if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1132	chunk = 65536;	1132	chunk = 65536;
1133	if (count < chunk)	1133	if (count < chunk)
1134	chunk = count;	1134	chunk = count;
1135		1135
1136	/* write_buf/write_cnt is protected by the atomic_write_lock mutex */	1136	/* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1137	if (tty->write_cnt < chunk) {	1137	if (tty->write_cnt < chunk) {
1138	unsigned char *buf_chunk;	1138	unsigned char *buf_chunk;
1139		1139
1140	if (chunk < 1024)	1140	if (chunk < 1024)
1141	chunk = 1024;	1141	chunk = 1024;
1142		1142
1143	buf_chunk = kmalloc(chunk, GFP_KERNEL);	1143	buf_chunk = kmalloc(chunk, GFP_KERNEL);
1144	if (!buf_chunk) {	1144	if (!buf_chunk) {
1145	ret = -ENOMEM;	1145	ret = -ENOMEM;
1146	goto out;	1146	goto out;
1147	}	1147	}
1148	kfree(tty->write_buf);	1148	kfree(tty->write_buf);
1149	tty->write_cnt = chunk;	1149	tty->write_cnt = chunk;
1150	tty->write_buf = buf_chunk;	1150	tty->write_buf = buf_chunk;
1151	}	1151	}
1152		1152
1153	/* Do the write .. */	1153	/* Do the write .. */
1154	for (;;) {	1154	for (;;) {
1155	size_t size = count;	1155	size_t size = count;
1156	if (size > chunk)	1156	if (size > chunk)
1157	size = chunk;	1157	size = chunk;
1158	ret = -EFAULT;	1158	ret = -EFAULT;
1159	if (copy_from_user(tty->write_buf, buf, size))	1159	if (copy_from_user(tty->write_buf, buf, size))
1160	break;	1160	break;
1161	ret = write(tty, file, tty->write_buf, size);	1161	ret = write(tty, file, tty->write_buf, size);
1162	if (ret <= 0)	1162	if (ret <= 0)
1163	break;	1163	break;
1164	written += ret;	1164	written += ret;
1165	buf += ret;	1165	buf += ret;
1166	count -= ret;	1166	count -= ret;
1167	if (!count)	1167	if (!count)
1168	break;	1168	break;
1169	ret = -ERESTARTSYS;	1169	ret = -ERESTARTSYS;
1170	if (signal_pending(current))	1170	if (signal_pending(current))
1171	break;	1171	break;
1172	cond_resched();	1172	cond_resched();
1173	}	1173	}
1174	if (written) {	1174	if (written) {
1175	tty_update_time(&file_inode(file)->i_mtime);	1175	tty_update_time(&file_inode(file)->i_mtime);
1176	ret = written;	1176	ret = written;
1177	}	1177	}
1178	out:	1178	out:
1179	tty_write_unlock(tty);	1179	tty_write_unlock(tty);
1180	return ret;	1180	return ret;
1181	}	1181	}
1182		1182
1183	/**	1183	/**
1184	* tty_write_message - write a message to a certain tty, not just the console.	1184	* tty_write_message - write a message to a certain tty, not just the console.
1185	* @tty: the destination tty_struct	1185	* @tty: the destination tty_struct
1186	* @msg: the message to write	1186	* @msg: the message to write
1187	*	1187	*
1188	* This is used for messages that need to be redirected to a specific tty.	1188	* This is used for messages that need to be redirected to a specific tty.
1189	* We don't put it into the syslog queue right now maybe in the future if	1189	* We don't put it into the syslog queue right now maybe in the future if
1190	* really needed.	1190	* really needed.
1191	*	1191	*
1192	* We must still hold the BTM and test the CLOSING flag for the moment.	1192	* We must still hold the BTM and test the CLOSING flag for the moment.
1193	*/	1193	*/
1194		1194
1195	void tty_write_message(struct tty_struct tty, char msg)	1195	void tty_write_message(struct tty_struct tty, char msg)
1196	{	1196	{
1197	if (tty) {	1197	if (tty) {
1198	mutex_lock(&tty->atomic_write_lock);	1198	mutex_lock(&tty->atomic_write_lock);
1199	tty_lock(tty);	1199	tty_lock(tty);
1200	if (tty->ops->write && tty->count > 0) {	1200	if (tty->ops->write && tty->count > 0) {
1201	tty_unlock(tty);	1201	tty_unlock(tty);
1202	tty->ops->write(tty, msg, strlen(msg));	1202	tty->ops->write(tty, msg, strlen(msg));
1203	} else	1203	} else
1204	tty_unlock(tty);	1204	tty_unlock(tty);
1205	tty_write_unlock(tty);	1205	tty_write_unlock(tty);
1206	}	1206	}
1207	return;	1207	return;
1208	}	1208	}
1209		1209
1210		1210
1211	/**	1211	/**
1212	* tty_write - write method for tty device file	1212	* tty_write - write method for tty device file
1213	* @file: tty file pointer	1213	* @file: tty file pointer
1214	* @buf: user data to write	1214	* @buf: user data to write
1215	* @count: bytes to write	1215	* @count: bytes to write
1216	* @ppos: unused	1216	* @ppos: unused
1217	*	1217	*
1218	* Write data to a tty device via the line discipline.	1218	* Write data to a tty device via the line discipline.
1219	*	1219	*
1220	* Locking:	1220	* Locking:
1221	* Locks the line discipline as required	1221	* Locks the line discipline as required
1222	* Writes to the tty driver are serialized by the atomic_write_lock	1222	* Writes to the tty driver are serialized by the atomic_write_lock
1223	* and are then processed in chunks to the device. The line discipline	1223	* and are then processed in chunks to the device. The line discipline
1224	* write method will not be invoked in parallel for each device.	1224	* write method will not be invoked in parallel for each device.
1225	*/	1225	*/
1226		1226
1227	static ssize_t tty_write(struct file file, const char __user buf,	1227	static ssize_t tty_write(struct file file, const char __user buf,
1228	size_t count, loff_t *ppos)	1228	size_t count, loff_t *ppos)
1229	{	1229	{
1230	struct tty_struct *tty = file_tty(file);	1230	struct tty_struct *tty = file_tty(file);
1231	struct tty_ldisc *ld;	1231	struct tty_ldisc *ld;
1232	ssize_t ret;	1232	ssize_t ret;
1233		1233
1234	if (tty_paranoia_check(tty, file_inode(file), "tty_write"))	1234	if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
1235	return -EIO;	1235	return -EIO;
1236	if (!tty \|\| !tty->ops->write \|\|	1236	if (!tty \|\| !tty->ops->write \|\|
1237	(test_bit(TTY_IO_ERROR, &tty->flags)))	1237	(test_bit(TTY_IO_ERROR, &tty->flags)))
1238	return -EIO;	1238	return -EIO;
1239	/* Short term debug to catch buggy drivers */	1239	/* Short term debug to catch buggy drivers */
1240	if (tty->ops->write_room == NULL)	1240	if (tty->ops->write_room == NULL)
1241	printk(KERN_ERR "tty driver %s lacks a write_room method.\n",	1241	printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1242	tty->driver->name);	1242	tty->driver->name);
1243	ld = tty_ldisc_ref_wait(tty);	1243	ld = tty_ldisc_ref_wait(tty);
1244	if (!ld->ops->write)	1244	if (!ld->ops->write)
1245	ret = -EIO;	1245	ret = -EIO;
1246	else	1246	else
1247	ret = do_tty_write(ld->ops->write, tty, file, buf, count);	1247	ret = do_tty_write(ld->ops->write, tty, file, buf, count);
1248	tty_ldisc_deref(ld);	1248	tty_ldisc_deref(ld);
1249	return ret;	1249	return ret;
1250	}	1250	}
1251		1251
1252	ssize_t redirected_tty_write(struct file file, const char __user buf,	1252	ssize_t redirected_tty_write(struct file file, const char __user buf,
1253	size_t count, loff_t *ppos)	1253	size_t count, loff_t *ppos)
1254	{	1254	{
1255	struct file *p = NULL;	1255	struct file *p = NULL;
1256		1256
1257	spin_lock(&redirect_lock);	1257	spin_lock(&redirect_lock);
1258	if (redirect)	1258	if (redirect)
1259	p = get_file(redirect);	1259	p = get_file(redirect);
1260	spin_unlock(&redirect_lock);	1260	spin_unlock(&redirect_lock);
1261		1261
1262	if (p) {	1262	if (p) {
1263	ssize_t res;	1263	ssize_t res;
1264	res = vfs_write(p, buf, count, &p->f_pos);	1264	res = vfs_write(p, buf, count, &p->f_pos);
1265	fput(p);	1265	fput(p);
1266	return res;	1266	return res;
1267	}	1267	}
1268	return tty_write(file, buf, count, ppos);	1268	return tty_write(file, buf, count, ppos);
1269	}	1269	}
1270		1270
1271	/**	1271	/**
1272	* tty_send_xchar - send priority character	1272	* tty_send_xchar - send priority character
1273	*	1273	*
1274	* Send a high priority character to the tty even if stopped	1274	* Send a high priority character to the tty even if stopped
1275	*	1275	*
1276	* Locking: none for xchar method, write ordering for write method.	1276	* Locking: none for xchar method, write ordering for write method.
1277	*/	1277	*/
1278		1278
1279	int tty_send_xchar(struct tty_struct *tty, char ch)	1279	int tty_send_xchar(struct tty_struct *tty, char ch)
1280	{	1280	{
1281	int was_stopped = tty->stopped;	1281	int was_stopped = tty->stopped;
1282		1282
1283	if (tty->ops->send_xchar) {	1283	if (tty->ops->send_xchar) {
1284	tty->ops->send_xchar(tty, ch);	1284	tty->ops->send_xchar(tty, ch);
1285	return 0;	1285	return 0;
1286	}	1286	}
1287		1287
1288	if (tty_write_lock(tty, 0) < 0)	1288	if (tty_write_lock(tty, 0) < 0)
1289	return -ERESTARTSYS;	1289	return -ERESTARTSYS;
1290		1290
1291	if (was_stopped)	1291	if (was_stopped)
1292	start_tty(tty);	1292	start_tty(tty);
1293	tty->ops->write(tty, &ch, 1);	1293	tty->ops->write(tty, &ch, 1);
1294	if (was_stopped)	1294	if (was_stopped)
1295	stop_tty(tty);	1295	stop_tty(tty);
1296	tty_write_unlock(tty);	1296	tty_write_unlock(tty);
1297	return 0;	1297	return 0;
1298	}	1298	}
1299		1299
1300	static char ptychar[] = "pqrstuvwxyzabcde";	1300	static char ptychar[] = "pqrstuvwxyzabcde";
1301		1301
1302	/**	1302	/**
1303	* pty_line_name - generate name for a pty	1303	* pty_line_name - generate name for a pty
1304	* @driver: the tty driver in use	1304	* @driver: the tty driver in use
1305	* @index: the minor number	1305	* @index: the minor number
1306	* @p: output buffer of at least 6 bytes	1306	* @p: output buffer of at least 6 bytes
1307	*	1307	*
1308	* Generate a name from a driver reference and write it to the output	1308	* Generate a name from a driver reference and write it to the output
1309	* buffer.	1309	* buffer.
1310	*	1310	*
1311	* Locking: None	1311	* Locking: None
1312	*/	1312	*/
1313	static void pty_line_name(struct tty_driver driver, int index, char p)	1313	static void pty_line_name(struct tty_driver driver, int index, char p)
1314	{	1314	{
1315	int i = index + driver->name_base;	1315	int i = index + driver->name_base;
1316	/* ->name is initialized to "ttyp", but "tty" is expected */	1316	/* ->name is initialized to "ttyp", but "tty" is expected */
1317	sprintf(p, "%s%c%x",	1317	sprintf(p, "%s%c%x",
1318	driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,	1318	driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1319	ptychar[i >> 4 & 0xf], i & 0xf);	1319	ptychar[i >> 4 & 0xf], i & 0xf);
1320	}	1320	}
1321		1321
1322	/**	1322	/**
1323	* tty_line_name - generate name for a tty	1323	* tty_line_name - generate name for a tty
1324	* @driver: the tty driver in use	1324	* @driver: the tty driver in use
1325	* @index: the minor number	1325	* @index: the minor number
1326	* @p: output buffer of at least 7 bytes	1326	* @p: output buffer of at least 7 bytes
1327	*	1327	*
1328	* Generate a name from a driver reference and write it to the output	1328	* Generate a name from a driver reference and write it to the output
1329	* buffer.	1329	* buffer.
1330	*	1330	*
1331	* Locking: None	1331	* Locking: None
1332	*/	1332	*/
1333	static ssize_t tty_line_name(struct tty_driver driver, int index, char p)	1333	static ssize_t tty_line_name(struct tty_driver driver, int index, char p)
1334	{	1334	{
1335	if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)	1335	if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
1336	return sprintf(p, "%s", driver->name);	1336	return sprintf(p, "%s", driver->name);
1337	else	1337	else
1338	return sprintf(p, "%s%d", driver->name,	1338	return sprintf(p, "%s%d", driver->name,
1339	index + driver->name_base);	1339	index + driver->name_base);
1340	}	1340	}
1341		1341
1342	/**	1342	/**
1343	* tty_driver_lookup_tty() - find an existing tty, if any	1343	* tty_driver_lookup_tty() - find an existing tty, if any
1344	* @driver: the driver for the tty	1344	* @driver: the driver for the tty
1345	* @idx: the minor number	1345	* @idx: the minor number
1346	*	1346	*
1347	* Return the tty, if found. If not found, return NULL or ERR_PTR() if the	1347	* Return the tty, if found. If not found, return NULL or ERR_PTR() if the
1348	* driver lookup() method returns an error.	1348	* driver lookup() method returns an error.
1349	*	1349	*
1350	* Locking: tty_mutex must be held. If the tty is found, bump the tty kref.	1350	* Locking: tty_mutex must be held. If the tty is found, bump the tty kref.
1351	*/	1351	*/
1352	static struct tty_struct tty_driver_lookup_tty(struct tty_driver driver,	1352	static struct tty_struct tty_driver_lookup_tty(struct tty_driver driver,
1353	struct inode *inode, int idx)	1353	struct inode *inode, int idx)
1354	{	1354	{
1355	struct tty_struct *tty;	1355	struct tty_struct *tty;
1356		1356
1357	if (driver->ops->lookup)	1357	if (driver->ops->lookup)
1358	tty = driver->ops->lookup(driver, inode, idx);	1358	tty = driver->ops->lookup(driver, inode, idx);
1359	else	1359	else
1360	tty = driver->ttys[idx];	1360	tty = driver->ttys[idx];
1361		1361
1362	if (!IS_ERR(tty))	1362	if (!IS_ERR(tty))
1363	tty_kref_get(tty);	1363	tty_kref_get(tty);
1364	return tty;	1364	return tty;
1365	}	1365	}
1366		1366
1367	/**	1367	/**
1368	* tty_init_termios - helper for termios setup	1368	* tty_init_termios - helper for termios setup
1369	* @tty: the tty to set up	1369	* @tty: the tty to set up
1370	*	1370	*
1371	* Initialise the termios structures for this tty. Thus runs under	1371	* Initialise the termios structures for this tty. Thus runs under
1372	* the tty_mutex currently so we can be relaxed about ordering.	1372	* the tty_mutex currently so we can be relaxed about ordering.
1373	*/	1373	*/
1374		1374
1375	int tty_init_termios(struct tty_struct *tty)	1375	int tty_init_termios(struct tty_struct *tty)
1376	{	1376	{
1377	struct ktermios *tp;	1377	struct ktermios *tp;
1378	int idx = tty->index;	1378	int idx = tty->index;
1379		1379
1380	if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)	1380	if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1381	tty->termios = tty->driver->init_termios;	1381	tty->termios = tty->driver->init_termios;
1382	else {	1382	else {
1383	/* Check for lazy saved data */	1383	/* Check for lazy saved data */
1384	tp = tty->driver->termios[idx];	1384	tp = tty->driver->termios[idx];
1385	if (tp != NULL)	1385	if (tp != NULL)
1386	tty->termios = *tp;	1386	tty->termios = *tp;
1387	else	1387	else
1388	tty->termios = tty->driver->init_termios;	1388	tty->termios = tty->driver->init_termios;
1389	}	1389	}
1390	/* Compatibility until drivers always set this */	1390	/* Compatibility until drivers always set this */
1391	tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);	1391	tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
1392	tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);	1392	tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
1393	return 0;	1393	return 0;
1394	}	1394	}
1395	EXPORT_SYMBOL_GPL(tty_init_termios);	1395	EXPORT_SYMBOL_GPL(tty_init_termios);
1396		1396
1397	int tty_standard_install(struct tty_driver driver, struct tty_struct tty)	1397	int tty_standard_install(struct tty_driver driver, struct tty_struct tty)
1398	{	1398	{
1399	int ret = tty_init_termios(tty);	1399	int ret = tty_init_termios(tty);
1400	if (ret)	1400	if (ret)
1401	return ret;	1401	return ret;
1402		1402
1403	tty_driver_kref_get(driver);	1403	tty_driver_kref_get(driver);
1404	tty->count++;	1404	tty->count++;
1405	driver->ttys[tty->index] = tty;	1405	driver->ttys[tty->index] = tty;
1406	return 0;	1406	return 0;
1407	}	1407	}
1408	EXPORT_SYMBOL_GPL(tty_standard_install);	1408	EXPORT_SYMBOL_GPL(tty_standard_install);
1409		1409
1410	/**	1410	/**
1411	* tty_driver_install_tty() - install a tty entry in the driver	1411	* tty_driver_install_tty() - install a tty entry in the driver
1412	* @driver: the driver for the tty	1412	* @driver: the driver for the tty
1413	* @tty: the tty	1413	* @tty: the tty
1414	*	1414	*
1415	* Install a tty object into the driver tables. The tty->index field	1415	* Install a tty object into the driver tables. The tty->index field
1416	* will be set by the time this is called. This method is responsible	1416	* will be set by the time this is called. This method is responsible
1417	* for ensuring any need additional structures are allocated and	1417	* for ensuring any need additional structures are allocated and
1418	* configured.	1418	* configured.
1419	*	1419	*
1420	* Locking: tty_mutex for now	1420	* Locking: tty_mutex for now
1421	*/	1421	*/
1422	static int tty_driver_install_tty(struct tty_driver *driver,	1422	static int tty_driver_install_tty(struct tty_driver *driver,
1423	struct tty_struct *tty)	1423	struct tty_struct *tty)
1424	{	1424	{
1425	return driver->ops->install ? driver->ops->install(driver, tty) :	1425	return driver->ops->install ? driver->ops->install(driver, tty) :
1426	tty_standard_install(driver, tty);	1426	tty_standard_install(driver, tty);
1427	}	1427	}
1428		1428
1429	/**	1429	/**
1430	* tty_driver_remove_tty() - remove a tty from the driver tables	1430	* tty_driver_remove_tty() - remove a tty from the driver tables
1431	* @driver: the driver for the tty	1431	* @driver: the driver for the tty
1432	* @idx: the minor number	1432	* @idx: the minor number
1433	*	1433	*
1434	* Remvoe a tty object from the driver tables. The tty->index field	1434	* Remvoe a tty object from the driver tables. The tty->index field
1435	* will be set by the time this is called.	1435	* will be set by the time this is called.
1436	*	1436	*
1437	* Locking: tty_mutex for now	1437	* Locking: tty_mutex for now
1438	*/	1438	*/
1439	void tty_driver_remove_tty(struct tty_driver driver, struct tty_struct tty)	1439	void tty_driver_remove_tty(struct tty_driver driver, struct tty_struct tty)
1440	{	1440	{
1441	if (driver->ops->remove)	1441	if (driver->ops->remove)
1442	driver->ops->remove(driver, tty);	1442	driver->ops->remove(driver, tty);
1443	else	1443	else
1444	driver->ttys[tty->index] = NULL;	1444	driver->ttys[tty->index] = NULL;
1445	}	1445	}
1446		1446
1447	/*	1447	/*
1448	* tty_reopen() - fast re-open of an open tty	1448	* tty_reopen() - fast re-open of an open tty
1449	* @tty - the tty to open	1449	* @tty - the tty to open
1450	*	1450	*
1451	* Return 0 on success, -errno on error.	1451	* Return 0 on success, -errno on error.
1452	* Re-opens on master ptys are not allowed and return -EIO.	1452	* Re-opens on master ptys are not allowed and return -EIO.
1453	*	1453	*
1454	* Locking: Caller must hold tty_lock	1454	* Locking: Caller must hold tty_lock
1455	*/	1455	*/
1456	static int tty_reopen(struct tty_struct *tty)	1456	static int tty_reopen(struct tty_struct *tty)
1457	{	1457	{
1458	struct tty_driver *driver = tty->driver;	1458	struct tty_driver *driver = tty->driver;
1459		1459
1460	if (!tty->count)	1460	if (!tty->count)
1461	return -EIO;	1461	return -EIO;
1462		1462
1463	if (driver->type == TTY_DRIVER_TYPE_PTY &&	1463	if (driver->type == TTY_DRIVER_TYPE_PTY &&
1464	driver->subtype == PTY_TYPE_MASTER)	1464	driver->subtype == PTY_TYPE_MASTER)
1465	return -EIO;	1465	return -EIO;
1466		1466
1467	if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))	1467	if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1468	return -EBUSY;	1468	return -EBUSY;
1469		1469
1470	tty->count++;	1470	tty->count++;
1471		1471
1472	WARN_ON(!tty->ldisc);	1472	WARN_ON(!tty->ldisc);
1473		1473
1474	return 0;	1474	return 0;
1475	}	1475	}
1476		1476
1477	/**	1477	/**
1478	* tty_init_dev - initialise a tty device	1478	* tty_init_dev - initialise a tty device
1479	* @driver: tty driver we are opening a device on	1479	* @driver: tty driver we are opening a device on
1480	* @idx: device index	1480	* @idx: device index
1481	* @ret_tty: returned tty structure	1481	* @ret_tty: returned tty structure
1482	*	1482	*
1483	* Prepare a tty device. This may not be a "new" clean device but	1483	* Prepare a tty device. This may not be a "new" clean device but
1484	* could also be an active device. The pty drivers require special	1484	* could also be an active device. The pty drivers require special
1485	* handling because of this.	1485	* handling because of this.
1486	*	1486	*
1487	* Locking:	1487	* Locking:
1488	* The function is called under the tty_mutex, which	1488	* The function is called under the tty_mutex, which
1489	* protects us from the tty struct or driver itself going away.	1489	* protects us from the tty struct or driver itself going away.
1490	*	1490	*
1491	* On exit the tty device has the line discipline attached and	1491	* On exit the tty device has the line discipline attached and
1492	* a reference count of 1. If a pair was created for pty/tty use	1492	* a reference count of 1. If a pair was created for pty/tty use
1493	* and the other was a pty master then it too has a reference count of 1.	1493	* and the other was a pty master then it too has a reference count of 1.
1494	*	1494	*
1495	* WSH 06/09/97: Rewritten to remove races and properly clean up after a	1495	* WSH 06/09/97: Rewritten to remove races and properly clean up after a
1496	* failed open. The new code protects the open with a mutex, so it's	1496	* failed open. The new code protects the open with a mutex, so it's
1497	* really quite straightforward. The mutex locking can probably be	1497	* really quite straightforward. The mutex locking can probably be
1498	* relaxed for the (most common) case of reopening a tty.	1498	* relaxed for the (most common) case of reopening a tty.
1499	*/	1499	*/
1500		1500
1501	struct tty_struct tty_init_dev(struct tty_driver driver, int idx)	1501	struct tty_struct tty_init_dev(struct tty_driver driver, int idx)
1502	{	1502	{
1503	struct tty_struct *tty;	1503	struct tty_struct *tty;
1504	int retval;	1504	int retval;
1505		1505
1506	/*	1506	/*
1507	* First time open is complex, especially for PTY devices.	1507	* First time open is complex, especially for PTY devices.
1508	* This code guarantees that either everything succeeds and the	1508	* This code guarantees that either everything succeeds and the
1509	* TTY is ready for operation, or else the table slots are vacated	1509	* TTY is ready for operation, or else the table slots are vacated
1510	* and the allocated memory released. (Except that the termios	1510	* and the allocated memory released. (Except that the termios
1511	* and locked termios may be retained.)	1511	* and locked termios may be retained.)
1512	*/	1512	*/
1513		1513
1514	if (!try_module_get(driver->owner))	1514	if (!try_module_get(driver->owner))
1515	return ERR_PTR(-ENODEV);	1515	return ERR_PTR(-ENODEV);
1516		1516
1517	tty = alloc_tty_struct(driver, idx);	1517	tty = alloc_tty_struct(driver, idx);
1518	if (!tty) {	1518	if (!tty) {
1519	retval = -ENOMEM;	1519	retval = -ENOMEM;
1520	goto err_module_put;	1520	goto err_module_put;
1521	}	1521	}
1522		1522
1523	tty_lock(tty);	1523	tty_lock(tty);
1524	retval = tty_driver_install_tty(driver, tty);	1524	retval = tty_driver_install_tty(driver, tty);
1525	if (retval < 0)	1525	if (retval < 0)
1526	goto err_deinit_tty;	1526	goto err_deinit_tty;
1527		1527
1528	if (!tty->port)	1528	if (!tty->port)
1529	tty->port = driver->ports[idx];	1529	tty->port = driver->ports[idx];
1530		1530
1531	WARN_RATELIMIT(!tty->port,	1531	WARN_RATELIMIT(!tty->port,
1532	"%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",	1532	"%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
1533	__func__, tty->driver->name);	1533	__func__, tty->driver->name);
1534		1534
1535	tty->port->itty = tty;	1535	tty->port->itty = tty;
1536		1536
1537	/*	1537	/*
1538	* Structures all installed ... call the ldisc open routines.	1538	* Structures all installed ... call the ldisc open routines.
1539	* If we fail here just call release_tty to clean up. No need	1539	* If we fail here just call release_tty to clean up. No need
1540	* to decrement the use counts, as release_tty doesn't care.	1540	* to decrement the use counts, as release_tty doesn't care.
1541	*/	1541	*/
1542	retval = tty_ldisc_setup(tty, tty->link);	1542	retval = tty_ldisc_setup(tty, tty->link);
1543	if (retval)	1543	if (retval)
1544	goto err_release_tty;	1544	goto err_release_tty;
1545	/* Return the tty locked so that it cannot vanish under the caller */	1545	/* Return the tty locked so that it cannot vanish under the caller */
1546	return tty;	1546	return tty;
1547		1547
1548	err_deinit_tty:	1548	err_deinit_tty:
1549	tty_unlock(tty);	1549	tty_unlock(tty);
1550	deinitialize_tty_struct(tty);	1550	deinitialize_tty_struct(tty);
1551	free_tty_struct(tty);	1551	free_tty_struct(tty);
1552	err_module_put:	1552	err_module_put:
1553	module_put(driver->owner);	1553	module_put(driver->owner);
1554	return ERR_PTR(retval);	1554	return ERR_PTR(retval);
1555		1555
1556	/* call the tty release_tty routine to clean out this slot */	1556	/* call the tty release_tty routine to clean out this slot */
1557	err_release_tty:	1557	err_release_tty:
1558	tty_unlock(tty);	1558	tty_unlock(tty);
1559	printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "	1559	printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "
1560	"clearing slot %d\n", idx);	1560	"clearing slot %d\n", idx);
1561	release_tty(tty, idx);	1561	release_tty(tty, idx);
1562	return ERR_PTR(retval);	1562	return ERR_PTR(retval);
1563	}	1563	}
1564		1564
1565	void tty_free_termios(struct tty_struct *tty)	1565	void tty_free_termios(struct tty_struct *tty)
1566	{	1566	{
1567	struct ktermios *tp;	1567	struct ktermios *tp;
1568	int idx = tty->index;	1568	int idx = tty->index;
1569		1569
1570	/* If the port is going to reset then it has no termios to save */	1570	/* If the port is going to reset then it has no termios to save */
1571	if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)	1571	if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1572	return;	1572	return;
1573		1573
1574	/* Stash the termios data */	1574	/* Stash the termios data */
1575	tp = tty->driver->termios[idx];	1575	tp = tty->driver->termios[idx];
1576	if (tp == NULL) {	1576	if (tp == NULL) {
1577	tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);	1577	tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
1578	if (tp == NULL) {	1578	if (tp == NULL) {
1579	pr_warn("tty: no memory to save termios state.\n");	1579	pr_warn("tty: no memory to save termios state.\n");
1580	return;	1580	return;
1581	}	1581	}
1582	tty->driver->termios[idx] = tp;	1582	tty->driver->termios[idx] = tp;
1583	}	1583	}
1584	*tp = tty->termios;	1584	*tp = tty->termios;
1585	}	1585	}
1586	EXPORT_SYMBOL(tty_free_termios);	1586	EXPORT_SYMBOL(tty_free_termios);
1587		1587
1588	/**	1588	/**
1589	* tty_flush_works - flush all works of a tty/pty pair	1589	* tty_flush_works - flush all works of a tty/pty pair
1590	* @tty: tty device to flush works for (or either end of a pty pair)	1590	* @tty: tty device to flush works for (or either end of a pty pair)
1591	*	1591	*
1592	* Sync flush all works belonging to @tty (and the 'other' tty).	1592	* Sync flush all works belonging to @tty (and the 'other' tty).
1593	*/	1593	*/
1594	static void tty_flush_works(struct tty_struct *tty)	1594	static void tty_flush_works(struct tty_struct *tty)
1595	{	1595	{
1596	flush_work(&tty->SAK_work);	1596	flush_work(&tty->SAK_work);
1597	flush_work(&tty->hangup_work);	1597	flush_work(&tty->hangup_work);
1598	if (tty->link) {	1598	if (tty->link) {
1599	flush_work(&tty->link->SAK_work);	1599	flush_work(&tty->link->SAK_work);
1600	flush_work(&tty->link->hangup_work);	1600	flush_work(&tty->link->hangup_work);
1601	}	1601	}
1602	}	1602	}
1603		1603
1604	/**	1604	/**
1605	* release_one_tty - release tty structure memory	1605	* release_one_tty - release tty structure memory
1606	* @kref: kref of tty we are obliterating	1606	* @kref: kref of tty we are obliterating
1607	*	1607	*
1608	* Releases memory associated with a tty structure, and clears out the	1608	* Releases memory associated with a tty structure, and clears out the
1609	* driver table slots. This function is called when a device is no longer	1609	* driver table slots. This function is called when a device is no longer
1610	* in use. It also gets called when setup of a device fails.	1610	* in use. It also gets called when setup of a device fails.
1611	*	1611	*
1612	* Locking:	1612	* Locking:
1613	* takes the file list lock internally when working on the list	1613	* takes the file list lock internally when working on the list
1614	* of ttys that the driver keeps.	1614	* of ttys that the driver keeps.
1615	*	1615	*
1616	* This method gets called from a work queue so that the driver private	1616	* This method gets called from a work queue so that the driver private
1617	* cleanup ops can sleep (needed for USB at least)	1617	* cleanup ops can sleep (needed for USB at least)
1618	*/	1618	*/
1619	static void release_one_tty(struct work_struct *work)	1619	static void release_one_tty(struct work_struct *work)
1620	{	1620	{
1621	struct tty_struct *tty =	1621	struct tty_struct *tty =
1622	container_of(work, struct tty_struct, hangup_work);	1622	container_of(work, struct tty_struct, hangup_work);
1623	struct tty_driver *driver = tty->driver;	1623	struct tty_driver *driver = tty->driver;
1624	struct module *owner = driver->owner;	1624	struct module *owner = driver->owner;
1625		1625
1626	if (tty->ops->cleanup)	1626	if (tty->ops->cleanup)
1627	tty->ops->cleanup(tty);	1627	tty->ops->cleanup(tty);
1628		1628
1629	tty->magic = 0;	1629	tty->magic = 0;
1630	tty_driver_kref_put(driver);	1630	tty_driver_kref_put(driver);
1631	module_put(owner);	1631	module_put(owner);
1632		1632
1633	spin_lock(&tty_files_lock);	1633	spin_lock(&tty_files_lock);
1634	list_del_init(&tty->tty_files);	1634	list_del_init(&tty->tty_files);
1635	spin_unlock(&tty_files_lock);	1635	spin_unlock(&tty_files_lock);
1636		1636
1637	put_pid(tty->pgrp);	1637	put_pid(tty->pgrp);
1638	put_pid(tty->session);	1638	put_pid(tty->session);
1639	free_tty_struct(tty);	1639	free_tty_struct(tty);
1640	}	1640	}
1641		1641
1642	static void queue_release_one_tty(struct kref *kref)	1642	static void queue_release_one_tty(struct kref *kref)
1643	{	1643	{
1644	struct tty_struct *tty = container_of(kref, struct tty_struct, kref);	1644	struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
1645		1645
1646	/* The hangup queue is now free so we can reuse it rather than	1646	/* The hangup queue is now free so we can reuse it rather than
1647	waste a chunk of memory for each port */	1647	waste a chunk of memory for each port */
1648	INIT_WORK(&tty->hangup_work, release_one_tty);	1648	INIT_WORK(&tty->hangup_work, release_one_tty);
1649	schedule_work(&tty->hangup_work);	1649	schedule_work(&tty->hangup_work);
1650	}	1650	}
1651		1651
1652	/**	1652	/**
1653	* tty_kref_put - release a tty kref	1653	* tty_kref_put - release a tty kref
1654	* @tty: tty device	1654	* @tty: tty device
1655	*	1655	*
1656	* Release a reference to a tty device and if need be let the kref	1656	* Release a reference to a tty device and if need be let the kref
1657	* layer destruct the object for us	1657	* layer destruct the object for us
1658	*/	1658	*/
1659		1659
1660	void tty_kref_put(struct tty_struct *tty)	1660	void tty_kref_put(struct tty_struct *tty)
1661	{	1661	{
1662	if (tty)	1662	if (tty)
1663	kref_put(&tty->kref, queue_release_one_tty);	1663	kref_put(&tty->kref, queue_release_one_tty);
1664	}	1664	}
1665	EXPORT_SYMBOL(tty_kref_put);	1665	EXPORT_SYMBOL(tty_kref_put);
1666		1666
1667	/**	1667	/**
1668	* release_tty - release tty structure memory	1668	* release_tty - release tty structure memory
1669	*	1669	*
1670	* Release both @tty and a possible linked partner (think pty pair),	1670	* Release both @tty and a possible linked partner (think pty pair),
1671	* and decrement the refcount of the backing module.	1671	* and decrement the refcount of the backing module.
1672	*	1672	*
1673	* Locking:	1673	* Locking:
1674	* tty_mutex	1674	* tty_mutex
1675	* takes the file list lock internally when working on the list	1675	* takes the file list lock internally when working on the list
1676	* of ttys that the driver keeps.	1676	* of ttys that the driver keeps.
1677	*	1677	*
1678	*/	1678	*/
1679	static void release_tty(struct tty_struct *tty, int idx)	1679	static void release_tty(struct tty_struct *tty, int idx)
1680	{	1680	{
1681	/* This should always be true but check for the moment */	1681	/* This should always be true but check for the moment */
1682	WARN_ON(tty->index != idx);	1682	WARN_ON(tty->index != idx);
1683	WARN_ON(!mutex_is_locked(&tty_mutex));	1683	WARN_ON(!mutex_is_locked(&tty_mutex));
1684	if (tty->ops->shutdown)	1684	if (tty->ops->shutdown)
1685	tty->ops->shutdown(tty);	1685	tty->ops->shutdown(tty);
1686	tty_free_termios(tty);	1686	tty_free_termios(tty);
1687	tty_driver_remove_tty(tty->driver, tty);	1687	tty_driver_remove_tty(tty->driver, tty);
1688	tty->port->itty = NULL;	1688	tty->port->itty = NULL;
1689	if (tty->link)	1689	if (tty->link)
1690	tty->link->port->itty = NULL;	1690	tty->link->port->itty = NULL;
1691	cancel_work_sync(&tty->port->buf.work);	1691	cancel_work_sync(&tty->port->buf.work);
1692		1692
1693	tty_kref_put(tty->link);	1693	tty_kref_put(tty->link);
1694	tty_kref_put(tty);	1694	tty_kref_put(tty);
1695	}	1695	}
1696		1696
1697	/**	1697	/**
1698	* tty_release_checks - check a tty before real release	1698	* tty_release_checks - check a tty before real release
1699	* @tty: tty to check	1699	* @tty: tty to check
1700	* @o_tty: link of @tty (if any)	1700	* @o_tty: link of @tty (if any)
1701	* @idx: index of the tty	1701	* @idx: index of the tty
1702	*	1702	*
1703	* Performs some paranoid checking before true release of the @tty.	1703	* Performs some paranoid checking before true release of the @tty.
1704	* This is a no-op unless TTY_PARANOIA_CHECK is defined.	1704	* This is a no-op unless TTY_PARANOIA_CHECK is defined.
1705	*/	1705	*/
1706	static int tty_release_checks(struct tty_struct *tty, int idx)	1706	static int tty_release_checks(struct tty_struct *tty, int idx)
1707	{	1707	{
1708	#ifdef TTY_PARANOIA_CHECK	1708	#ifdef TTY_PARANOIA_CHECK
1709	if (idx < 0 \|\| idx >= tty->driver->num) {	1709	if (idx < 0 \|\| idx >= tty->driver->num) {
1710	printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",	1710	printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",
1711	__func__, tty->name);	1711	__func__, tty->name);
1712	return -1;	1712	return -1;
1713	}	1713	}
1714		1714
1715	/* not much to check for devpts */	1715	/* not much to check for devpts */
1716	if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)	1716	if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1717	return 0;	1717	return 0;
1718		1718
1719	if (tty != tty->driver->ttys[idx]) {	1719	if (tty != tty->driver->ttys[idx]) {
1720	printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",	1720	printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",
1721	__func__, idx, tty->name);	1721	__func__, idx, tty->name);
1722	return -1;	1722	return -1;
1723	}	1723	}
1724	if (tty->driver->other) {	1724	if (tty->driver->other) {
1725	struct tty_struct *o_tty = tty->link;	1725	struct tty_struct *o_tty = tty->link;
1726		1726
1727	if (o_tty != tty->driver->other->ttys[idx]) {	1727	if (o_tty != tty->driver->other->ttys[idx]) {
1728	printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",	1728	printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",
1729	__func__, idx, tty->name);	1729	__func__, idx, tty->name);
1730	return -1;	1730	return -1;
1731	}	1731	}
1732	if (o_tty->link != tty) {	1732	if (o_tty->link != tty) {
1733	printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);	1733	printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);
1734	return -1;	1734	return -1;
1735	}	1735	}
1736	}	1736	}
1737	#endif	1737	#endif
1738	return 0;	1738	return 0;
1739	}	1739	}
1740		1740
1741	/**	1741	/**
1742	* tty_release - vfs callback for close	1742	* tty_release - vfs callback for close
1743	* @inode: inode of tty	1743	* @inode: inode of tty
1744	* @filp: file pointer for handle to tty	1744	* @filp: file pointer for handle to tty
1745	*	1745	*
1746	* Called the last time each file handle is closed that references	1746	* Called the last time each file handle is closed that references
1747	* this tty. There may however be several such references.	1747	* this tty. There may however be several such references.
1748	*	1748	*
1749	* Locking:	1749	* Locking:
1750	* Takes bkl. See tty_release_dev	1750	* Takes bkl. See tty_release_dev
1751	*	1751	*
1752	* Even releasing the tty structures is a tricky business.. We have	1752	* Even releasing the tty structures is a tricky business.. We have
1753	* to be very careful that the structures are all released at the	1753	* to be very careful that the structures are all released at the
1754	* same time, as interrupts might otherwise get the wrong pointers.	1754	* same time, as interrupts might otherwise get the wrong pointers.
1755	*	1755	*
1756	* WSH 09/09/97: rewritten to avoid some nasty race conditions that could	1756	* WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1757	* lead to double frees or releasing memory still in use.	1757	* lead to double frees or releasing memory still in use.
1758	*/	1758	*/
1759		1759
1760	int tty_release(struct inode inode, struct file filp)	1760	int tty_release(struct inode inode, struct file filp)
1761	{	1761	{
1762	struct tty_struct *tty = file_tty(filp);	1762	struct tty_struct *tty = file_tty(filp);
1763	struct tty_struct *o_tty = NULL;	1763	struct tty_struct *o_tty = NULL;
1764	int do_sleep, final;	1764	int do_sleep, final;
1765	int idx;	1765	int idx;
1766	char buf[64];	1766	char buf[64];
1767	long timeout = 0;	1767	long timeout = 0;
1768	int once = 1;	1768	int once = 1;
1769		1769
1770	if (tty_paranoia_check(tty, inode, __func__))	1770	if (tty_paranoia_check(tty, inode, __func__))
1771	return 0;	1771	return 0;
1772		1772
1773	tty_lock(tty);	1773	tty_lock(tty);
1774	check_tty_count(tty, __func__);	1774	check_tty_count(tty, __func__);
1775		1775
1776	__tty_fasync(-1, filp, 0);	1776	__tty_fasync(-1, filp, 0);
1777		1777
1778	idx = tty->index;	1778	idx = tty->index;
1779	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&	1779	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1780	tty->driver->subtype == PTY_TYPE_MASTER)	1780	tty->driver->subtype == PTY_TYPE_MASTER)
1781	o_tty = tty->link;	1781	o_tty = tty->link;
1782		1782
1783	if (tty_release_checks(tty, idx)) {	1783	if (tty_release_checks(tty, idx)) {
1784	tty_unlock(tty);	1784	tty_unlock(tty);
1785	return 0;	1785	return 0;
1786	}	1786	}
1787		1787
1788	#ifdef TTY_DEBUG_HANGUP	1788	#ifdef TTY_DEBUG_HANGUP
1789	printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,	1789	printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,
1790	tty_name(tty, buf), tty->count);	1790	tty_name(tty, buf), tty->count);
1791	#endif	1791	#endif
1792		1792
1793	if (tty->ops->close)	1793	if (tty->ops->close)
1794	tty->ops->close(tty, filp);	1794	tty->ops->close(tty, filp);
1795		1795
1796	/* If tty is pty master, lock the slave pty (stable lock order) */	1796	/* If tty is pty master, lock the slave pty (stable lock order) */
1797	tty_lock_slave(o_tty);	1797	tty_lock_slave(o_tty);
1798		1798
1799	/*	1799	/*
1800	* Sanity check: if tty->count is going to zero, there shouldn't be	1800	* Sanity check: if tty->count is going to zero, there shouldn't be
1801	* any waiters on tty->read_wait or tty->write_wait. We test the	1801	* any waiters on tty->read_wait or tty->write_wait. We test the
1802	* wait queues and kick everyone out _before_ actually starting to	1802	* wait queues and kick everyone out _before_ actually starting to
1803	* close. This ensures that we won't block while releasing the tty	1803	* close. This ensures that we won't block while releasing the tty
1804	* structure.	1804	* structure.
1805	*	1805	*
1806	* The test for the o_tty closing is necessary, since the master and	1806	* The test for the o_tty closing is necessary, since the master and
1807	* slave sides may close in any order. If the slave side closes out	1807	* slave sides may close in any order. If the slave side closes out
1808	* first, its count will be one, since the master side holds an open.	1808	* first, its count will be one, since the master side holds an open.
1809	* Thus this test wouldn't be triggered at the time the slave closed,	1809	* Thus this test wouldn't be triggered at the time the slave closed,
1810	* so we do it now.	1810	* so we do it now.
1811	*/	1811	*/
1812	while (1) {	1812	while (1) {
1813	do_sleep = 0;	1813	do_sleep = 0;
1814		1814
1815	if (tty->count <= 1) {	1815	if (tty->count <= 1) {
1816	if (waitqueue_active(&tty->read_wait)) {	1816	if (waitqueue_active(&tty->read_wait)) {
1817	wake_up_poll(&tty->read_wait, POLLIN);	1817	wake_up_poll(&tty->read_wait, POLLIN);
1818	do_sleep++;	1818	do_sleep++;
1819	}	1819	}
1820	if (waitqueue_active(&tty->write_wait)) {	1820	if (waitqueue_active(&tty->write_wait)) {
1821	wake_up_poll(&tty->write_wait, POLLOUT);	1821	wake_up_poll(&tty->write_wait, POLLOUT);
1822	do_sleep++;	1822	do_sleep++;
1823	}	1823	}
1824	}	1824	}
1825	if (o_tty && o_tty->count <= 1) {	1825	if (o_tty && o_tty->count <= 1) {
1826	if (waitqueue_active(&o_tty->read_wait)) {	1826	if (waitqueue_active(&o_tty->read_wait)) {
1827	wake_up_poll(&o_tty->read_wait, POLLIN);	1827	wake_up_poll(&o_tty->read_wait, POLLIN);
1828	do_sleep++;	1828	do_sleep++;
1829	}	1829	}
1830	if (waitqueue_active(&o_tty->write_wait)) {	1830	if (waitqueue_active(&o_tty->write_wait)) {
1831	wake_up_poll(&o_tty->write_wait, POLLOUT);	1831	wake_up_poll(&o_tty->write_wait, POLLOUT);
1832	do_sleep++;	1832	do_sleep++;
1833	}	1833	}
1834	}	1834	}
1835	if (!do_sleep)	1835	if (!do_sleep)
1836	break;	1836	break;
1837		1837
1838	if (once) {	1838	if (once) {
1839	once = 0;	1839	once = 0;
1840	printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",	1840	printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",
1841	__func__, tty_name(tty, buf));	1841	__func__, tty_name(tty, buf));
1842	}	1842	}
1843	schedule_timeout_killable(timeout);	1843	schedule_timeout_killable(timeout);
1844	if (timeout < 120 * HZ)	1844	if (timeout < 120 * HZ)
1845	timeout = 2 * timeout + 1;	1845	timeout = 2 * timeout + 1;
1846	else	1846	else
1847	timeout = MAX_SCHEDULE_TIMEOUT;	1847	timeout = MAX_SCHEDULE_TIMEOUT;
1848	}	1848	}
1849		1849
1850	if (o_tty) {	1850	if (o_tty) {
1851	if (--o_tty->count < 0) {	1851	if (--o_tty->count < 0) {
1852	printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",	1852	printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",
1853	__func__, o_tty->count, tty_name(o_tty, buf));	1853	__func__, o_tty->count, tty_name(o_tty, buf));
1854	o_tty->count = 0;	1854	o_tty->count = 0;
1855	}	1855	}
1856	}	1856	}
1857	if (--tty->count < 0) {	1857	if (--tty->count < 0) {
1858	printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",	1858	printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",
1859	__func__, tty->count, tty_name(tty, buf));	1859	__func__, tty->count, tty_name(tty, buf));
1860	tty->count = 0;	1860	tty->count = 0;
1861	}	1861	}
1862		1862
1863	/*	1863	/*
1864	* We've decremented tty->count, so we need to remove this file	1864	* We've decremented tty->count, so we need to remove this file
1865	* descriptor off the tty->tty_files list; this serves two	1865	* descriptor off the tty->tty_files list; this serves two
1866	* purposes:	1866	* purposes:
1867	* - check_tty_count sees the correct number of file descriptors	1867	* - check_tty_count sees the correct number of file descriptors
1868	* associated with this tty.	1868	* associated with this tty.
1869	* - do_tty_hangup no longer sees this file descriptor as	1869	* - do_tty_hangup no longer sees this file descriptor as
1870	* something that needs to be handled for hangups.	1870	* something that needs to be handled for hangups.
1871	*/	1871	*/
1872	tty_del_file(filp);	1872	tty_del_file(filp);
1873		1873
1874	/*	1874	/*
1875	* Perform some housekeeping before deciding whether to return.	1875	* Perform some housekeeping before deciding whether to return.
1876	*	1876	*
1877	* If _either_ side is closing, make sure there aren't any	1877	* If _either_ side is closing, make sure there aren't any
1878	* processes that still think tty or o_tty is their controlling	1878	* processes that still think tty or o_tty is their controlling
1879	* tty.	1879	* tty.
1880	*/	1880	*/
1881	if (!tty->count) {	1881	if (!tty->count) {
1882	read_lock(&tasklist_lock);	1882	read_lock(&tasklist_lock);
1883	session_clear_tty(tty->session);	1883	session_clear_tty(tty->session);
1884	if (o_tty)	1884	if (o_tty)
1885	session_clear_tty(o_tty->session);	1885	session_clear_tty(o_tty->session);
1886	read_unlock(&tasklist_lock);	1886	read_unlock(&tasklist_lock);
1887	}	1887	}
1888		1888
1889	/* check whether both sides are closing ... */	1889	/* check whether both sides are closing ... */
1890	final = !tty->count && !(o_tty && o_tty->count);	1890	final = !tty->count && !(o_tty && o_tty->count);
1891		1891
1892	tty_unlock_slave(o_tty);	1892	tty_unlock_slave(o_tty);
1893	tty_unlock(tty);	1893	tty_unlock(tty);
1894		1894
1895	/* At this point, the tty->count == 0 should ensure a dead tty	1895	/* At this point, the tty->count == 0 should ensure a dead tty
1896	cannot be re-opened by a racing opener */	1896	cannot be re-opened by a racing opener */
1897		1897
1898	if (!final)	1898	if (!final)
1899	return 0;	1899	return 0;
1900		1900
1901	#ifdef TTY_DEBUG_HANGUP	1901	#ifdef TTY_DEBUG_HANGUP
1902	printk(KERN_DEBUG "%s: %s: final close\n", __func__, tty_name(tty, buf));	1902	printk(KERN_DEBUG "%s: %s: final close\n", __func__, tty_name(tty, buf));
1903	#endif	1903	#endif
1904	/*	1904	/*
1905	* Ask the line discipline code to release its structures	1905	* Ask the line discipline code to release its structures
1906	*/	1906	*/
1907	tty_ldisc_release(tty);	1907	tty_ldisc_release(tty);
1908		1908
1909	/* Wait for pending work before tty destruction commmences */	1909	/* Wait for pending work before tty destruction commmences */
1910	tty_flush_works(tty);	1910	tty_flush_works(tty);
1911		1911
1912	#ifdef TTY_DEBUG_HANGUP	1912	#ifdef TTY_DEBUG_HANGUP
1913	printk(KERN_DEBUG "%s: %s: freeing structure...\n", __func__, tty_name(tty, buf));	1913	printk(KERN_DEBUG "%s: %s: freeing structure...\n", __func__, tty_name(tty, buf));
1914	#endif	1914	#endif
1915	/*	1915	/*
1916	* The release_tty function takes care of the details of clearing	1916	* The release_tty function takes care of the details of clearing
1917	* the slots and preserving the termios structure. The tty_unlock_pair	1917	* the slots and preserving the termios structure. The tty_unlock_pair
1918	* should be safe as we keep a kref while the tty is locked (so the	1918	* should be safe as we keep a kref while the tty is locked (so the
1919	* unlock never unlocks a freed tty).	1919	* unlock never unlocks a freed tty).
1920	*/	1920	*/
1921	mutex_lock(&tty_mutex);	1921	mutex_lock(&tty_mutex);
1922	release_tty(tty, idx);	1922	release_tty(tty, idx);
1923	mutex_unlock(&tty_mutex);	1923	mutex_unlock(&tty_mutex);
1924		1924
1925	return 0;	1925	return 0;
1926	}	1926	}
1927		1927
1928	/**	1928	/**
1929	* tty_open_current_tty - get locked tty of current task	1929	* tty_open_current_tty - get locked tty of current task
1930	* @device: device number	1930	* @device: device number
1931	* @filp: file pointer to tty	1931	* @filp: file pointer to tty
1932	* @return: locked tty of the current task iff @device is /dev/tty	1932	* @return: locked tty of the current task iff @device is /dev/tty
1933	*	1933	*
1934	* Performs a re-open of the current task's controlling tty.	1934	* Performs a re-open of the current task's controlling tty.
1935	*	1935	*
1936	* We cannot return driver and index like for the other nodes because	1936	* We cannot return driver and index like for the other nodes because
1937	* devpts will not work then. It expects inodes to be from devpts FS.	1937	* devpts will not work then. It expects inodes to be from devpts FS.
1938	*/	1938	*/
1939	static struct tty_struct tty_open_current_tty(dev_t device, struct file filp)	1939	static struct tty_struct tty_open_current_tty(dev_t device, struct file filp)
1940	{	1940	{
1941	struct tty_struct *tty;	1941	struct tty_struct *tty;
1942	int retval;	1942	int retval;
1943		1943
1944	if (device != MKDEV(TTYAUX_MAJOR, 0))	1944	if (device != MKDEV(TTYAUX_MAJOR, 0))
1945	return NULL;	1945	return NULL;
1946		1946
1947	tty = get_current_tty();	1947	tty = get_current_tty();
1948	if (!tty)	1948	if (!tty)
1949	return ERR_PTR(-ENXIO);	1949	return ERR_PTR(-ENXIO);
1950		1950
1951	filp->f_flags \|= O_NONBLOCK; /* Don't let /dev/tty block */	1951	filp->f_flags \|= O_NONBLOCK; /* Don't let /dev/tty block */
1952	/* noctty = 1; */	1952	/* noctty = 1; */
1953	tty_lock(tty);	1953	tty_lock(tty);
1954	tty_kref_put(tty); /* safe to drop the kref now */	1954	tty_kref_put(tty); /* safe to drop the kref now */
1955		1955
1956	retval = tty_reopen(tty);	1956	retval = tty_reopen(tty);
1957	if (retval < 0) {	1957	if (retval < 0) {
1958	tty_unlock(tty);	1958	tty_unlock(tty);
1959	tty = ERR_PTR(retval);	1959	tty = ERR_PTR(retval);
1960	}	1960	}
1961	return tty;	1961	return tty;
1962	}	1962	}
1963		1963
1964	/**	1964	/**
1965	* tty_lookup_driver - lookup a tty driver for a given device file	1965	* tty_lookup_driver - lookup a tty driver for a given device file
1966	* @device: device number	1966	* @device: device number
1967	* @filp: file pointer to tty	1967	* @filp: file pointer to tty
1968	* @noctty: set if the device should not become a controlling tty	1968	* @noctty: set if the device should not become a controlling tty
1969	* @index: index for the device in the @return driver	1969	* @index: index for the device in the @return driver
1970	* @return: driver for this inode (with increased refcount)	1970	* @return: driver for this inode (with increased refcount)
1971	*	1971	*
1972	* If @return is not erroneous, the caller is responsible to decrement the	1972	* If @return is not erroneous, the caller is responsible to decrement the
1973	* refcount by tty_driver_kref_put.	1973	* refcount by tty_driver_kref_put.
1974	*	1974	*
1975	* Locking: tty_mutex protects get_tty_driver	1975	* Locking: tty_mutex protects get_tty_driver
1976	*/	1976	*/
1977	static struct tty_driver tty_lookup_driver(dev_t device, struct file filp,	1977	static struct tty_driver tty_lookup_driver(dev_t device, struct file filp,
1978	int noctty, int index)	1978	int noctty, int index)
1979	{	1979	{
1980	struct tty_driver *driver;	1980	struct tty_driver *driver;
1981		1981
1982	switch (device) {	1982	switch (device) {
1983	#ifdef CONFIG_VT	1983	#ifdef CONFIG_VT
1984	case MKDEV(TTY_MAJOR, 0): {	1984	case MKDEV(TTY_MAJOR, 0): {
1985	extern struct tty_driver *console_driver;	1985	extern struct tty_driver *console_driver;
1986	driver = tty_driver_kref_get(console_driver);	1986	driver = tty_driver_kref_get(console_driver);
1987	*index = fg_console;	1987	*index = fg_console;
1988	*noctty = 1;	1988	*noctty = 1;
1989	break;	1989	break;
1990	}	1990	}
1991	#endif	1991	#endif
1992	case MKDEV(TTYAUX_MAJOR, 1): {	1992	case MKDEV(TTYAUX_MAJOR, 1): {
1993	struct tty_driver *console_driver = console_device(index);	1993	struct tty_driver *console_driver = console_device(index);
1994	if (console_driver) {	1994	if (console_driver) {
1995	driver = tty_driver_kref_get(console_driver);	1995	driver = tty_driver_kref_get(console_driver);
1996	if (driver) {	1996	if (driver) {
1997	/* Don't let /dev/console block */	1997	/* Don't let /dev/console block */
1998	filp->f_flags \|= O_NONBLOCK;	1998	filp->f_flags \|= O_NONBLOCK;
1999	*noctty = 1;	1999	*noctty = 1;
2000	break;	2000	break;
2001	}	2001	}
2002	}	2002	}
2003	return ERR_PTR(-ENODEV);	2003	return ERR_PTR(-ENODEV);
2004	}	2004	}
2005	default:	2005	default:
2006	driver = get_tty_driver(device, index);	2006	driver = get_tty_driver(device, index);
2007	if (!driver)	2007	if (!driver)
2008	return ERR_PTR(-ENODEV);	2008	return ERR_PTR(-ENODEV);
2009	break;	2009	break;
2010	}	2010	}
2011	return driver;	2011	return driver;
2012	}	2012	}
2013		2013
2014	/**	2014	/**
2015	* tty_open - open a tty device	2015	* tty_open - open a tty device
2016	* @inode: inode of device file	2016	* @inode: inode of device file
2017	* @filp: file pointer to tty	2017	* @filp: file pointer to tty
2018	*	2018	*
2019	* tty_open and tty_release keep up the tty count that contains the	2019	* tty_open and tty_release keep up the tty count that contains the
2020	* number of opens done on a tty. We cannot use the inode-count, as	2020	* number of opens done on a tty. We cannot use the inode-count, as
2021	* different inodes might point to the same tty.	2021	* different inodes might point to the same tty.
2022	*	2022	*
2023	* Open-counting is needed for pty masters, as well as for keeping	2023	* Open-counting is needed for pty masters, as well as for keeping
2024	* track of serial lines: DTR is dropped when the last close happens.	2024	* track of serial lines: DTR is dropped when the last close happens.
2025	* (This is not done solely through tty->count, now. - Ted 1/27/92)	2025	* (This is not done solely through tty->count, now. - Ted 1/27/92)
2026	*	2026	*
2027	* The termios state of a pty is reset on first open so that	2027	* The termios state of a pty is reset on first open so that
2028	* settings don't persist across reuse.	2028	* settings don't persist across reuse.
2029	*	2029	*
2030	* Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.	2030	* Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
2031	* tty->count should protect the rest.	2031	* tty->count should protect the rest.
2032	* ->siglock protects ->signal/->sighand	2032	* ->siglock protects ->signal/->sighand
2033	*	2033	*
2034	* Note: the tty_unlock/lock cases without a ref are only safe due to	2034	* Note: the tty_unlock/lock cases without a ref are only safe due to
2035	* tty_mutex	2035	* tty_mutex
2036	*/	2036	*/
2037		2037
2038	static int tty_open(struct inode inode, struct file filp)	2038	static int tty_open(struct inode inode, struct file filp)
2039	{	2039	{
2040	struct tty_struct *tty;	2040	struct tty_struct *tty;
2041	int noctty, retval;	2041	int noctty, retval;
2042	struct tty_driver *driver = NULL;	2042	struct tty_driver *driver = NULL;
2043	int index;	2043	int index;
2044	dev_t device = inode->i_rdev;	2044	dev_t device = inode->i_rdev;
2045	unsigned saved_flags = filp->f_flags;	2045	unsigned saved_flags = filp->f_flags;
2046		2046
2047	nonseekable_open(inode, filp);	2047	nonseekable_open(inode, filp);
2048		2048
2049	retry_open:	2049	retry_open:
2050	retval = tty_alloc_file(filp);	2050	retval = tty_alloc_file(filp);
2051	if (retval)	2051	if (retval)
2052	return -ENOMEM;	2052	return -ENOMEM;
2053		2053
2054	noctty = filp->f_flags & O_NOCTTY;	2054	noctty = filp->f_flags & O_NOCTTY;
2055	index = -1;	2055	index = -1;
2056	retval = 0;	2056	retval = 0;
2057		2057
2058	tty = tty_open_current_tty(device, filp);	2058	tty = tty_open_current_tty(device, filp);
2059	if (!tty) {	2059	if (!tty) {
2060	mutex_lock(&tty_mutex);	2060	mutex_lock(&tty_mutex);
2061	driver = tty_lookup_driver(device, filp, &noctty, &index);	2061	driver = tty_lookup_driver(device, filp, &noctty, &index);
2062	if (IS_ERR(driver)) {	2062	if (IS_ERR(driver)) {
2063	retval = PTR_ERR(driver);	2063	retval = PTR_ERR(driver);
2064	goto err_unlock;	2064	goto err_unlock;
2065	}	2065	}
2066		2066
2067	/* check whether we're reopening an existing tty */	2067	/* check whether we're reopening an existing tty */
2068	tty = tty_driver_lookup_tty(driver, inode, index);	2068	tty = tty_driver_lookup_tty(driver, inode, index);
2069	if (IS_ERR(tty)) {	2069	if (IS_ERR(tty)) {
2070	retval = PTR_ERR(tty);	2070	retval = PTR_ERR(tty);
2071	goto err_unlock;	2071	goto err_unlock;
2072	}	2072	}
2073		2073
2074	if (tty) {	2074	if (tty) {
2075	mutex_unlock(&tty_mutex);	2075	mutex_unlock(&tty_mutex);
2076	tty_lock(tty);	2076	tty_lock(tty);
2077	/* safe to drop the kref from tty_driver_lookup_tty() */	2077	/* safe to drop the kref from tty_driver_lookup_tty() */
2078	tty_kref_put(tty);	2078	tty_kref_put(tty);
2079	retval = tty_reopen(tty);	2079	retval = tty_reopen(tty);
2080	if (retval < 0) {	2080	if (retval < 0) {
2081	tty_unlock(tty);	2081	tty_unlock(tty);
2082	tty = ERR_PTR(retval);	2082	tty = ERR_PTR(retval);
2083	}	2083	}
2084	} else { /* Returns with the tty_lock held for now */	2084	} else { /* Returns with the tty_lock held for now */
2085	tty = tty_init_dev(driver, index);	2085	tty = tty_init_dev(driver, index);
2086	mutex_unlock(&tty_mutex);	2086	mutex_unlock(&tty_mutex);
2087	}	2087	}
2088		2088
2089	tty_driver_kref_put(driver);	2089	tty_driver_kref_put(driver);
2090	}	2090	}
2091		2091
2092	if (IS_ERR(tty)) {	2092	if (IS_ERR(tty)) {
2093	retval = PTR_ERR(tty);	2093	retval = PTR_ERR(tty);
2094	goto err_file;	2094	goto err_file;
2095	}	2095	}
2096		2096
2097	tty_add_file(tty, filp);	2097	tty_add_file(tty, filp);
2098		2098
2099	check_tty_count(tty, __func__);	2099	check_tty_count(tty, __func__);
2100	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&	2100	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2101	tty->driver->subtype == PTY_TYPE_MASTER)	2101	tty->driver->subtype == PTY_TYPE_MASTER)
2102	noctty = 1;	2102	noctty = 1;
2103	#ifdef TTY_DEBUG_HANGUP	2103	#ifdef TTY_DEBUG_HANGUP
2104	printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);	2104	printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);
2105	#endif	2105	#endif
2106	if (tty->ops->open)	2106	if (tty->ops->open)
2107	retval = tty->ops->open(tty, filp);	2107	retval = tty->ops->open(tty, filp);
2108	else	2108	else
2109	retval = -ENODEV;	2109	retval = -ENODEV;
2110	filp->f_flags = saved_flags;	2110	filp->f_flags = saved_flags;
2111		2111
2112	if (retval) {	2112	if (retval) {
2113	#ifdef TTY_DEBUG_HANGUP	2113	#ifdef TTY_DEBUG_HANGUP
2114	printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,	2114	printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,
2115	retval, tty->name);	2115	retval, tty->name);
2116	#endif	2116	#endif
2117	tty_unlock(tty); /* need to call tty_release without BTM */	2117	tty_unlock(tty); /* need to call tty_release without BTM */
2118	tty_release(inode, filp);	2118	tty_release(inode, filp);
2119	if (retval != -ERESTARTSYS)	2119	if (retval != -ERESTARTSYS)
2120	return retval;	2120	return retval;
2121		2121
2122	if (signal_pending(current))	2122	if (signal_pending(current))
2123	return retval;	2123	return retval;
2124		2124
2125	schedule();	2125	schedule();
2126	/*	2126	/*
2127	* Need to reset f_op in case a hangup happened.	2127	* Need to reset f_op in case a hangup happened.
2128	*/	2128	*/
2129	if (tty_hung_up_p(filp))	2129	if (tty_hung_up_p(filp))
2130	filp->f_op = &tty_fops;	2130	filp->f_op = &tty_fops;
2131	goto retry_open;	2131	goto retry_open;
2132	}	2132	}
2133	clear_bit(TTY_HUPPED, &tty->flags);	2133	clear_bit(TTY_HUPPED, &tty->flags);
2134		2134
2135		2135
2136	read_lock(&tasklist_lock);	2136	read_lock(&tasklist_lock);
2137	spin_lock_irq(&current->sighand->siglock);	2137	spin_lock_irq(&current->sighand->siglock);
2138	if (!noctty &&	2138	if (!noctty &&
2139	current->signal->leader &&	2139	current->signal->leader &&
2140	!current->signal->tty &&	2140	!current->signal->tty &&
2141	tty->session == NULL)	2141	tty->session == NULL)
2142	__proc_set_tty(tty);	2142	__proc_set_tty(tty);
2143	spin_unlock_irq(&current->sighand->siglock);	2143	spin_unlock_irq(&current->sighand->siglock);
2144	read_unlock(&tasklist_lock);	2144	read_unlock(&tasklist_lock);
2145	tty_unlock(tty);	2145	tty_unlock(tty);
2146	return 0;	2146	return 0;
2147	err_unlock:	2147	err_unlock:
2148	mutex_unlock(&tty_mutex);	2148	mutex_unlock(&tty_mutex);
2149	/* after locks to avoid deadlock */	2149	/* after locks to avoid deadlock */
2150	if (!IS_ERR_OR_NULL(driver))	2150	if (!IS_ERR_OR_NULL(driver))
2151	tty_driver_kref_put(driver);	2151	tty_driver_kref_put(driver);
2152	err_file:	2152	err_file:
2153	tty_free_file(filp);	2153	tty_free_file(filp);
2154	return retval;	2154	return retval;
2155	}	2155	}
2156		2156
2157		2157
2158		2158
2159	/**	2159	/**
2160	* tty_poll - check tty status	2160	* tty_poll - check tty status
2161	* @filp: file being polled	2161	* @filp: file being polled
2162	* @wait: poll wait structures to update	2162	* @wait: poll wait structures to update
2163	*	2163	*
2164	* Call the line discipline polling method to obtain the poll	2164	* Call the line discipline polling method to obtain the poll
2165	* status of the device.	2165	* status of the device.
2166	*	2166	*
2167	* Locking: locks called line discipline but ldisc poll method	2167	* Locking: locks called line discipline but ldisc poll method
2168	* may be re-entered freely by other callers.	2168	* may be re-entered freely by other callers.
2169	*/	2169	*/
2170		2170
2171	static unsigned int tty_poll(struct file filp, poll_table wait)	2171	static unsigned int tty_poll(struct file filp, poll_table wait)
2172	{	2172	{
2173	struct tty_struct *tty = file_tty(filp);	2173	struct tty_struct *tty = file_tty(filp);
2174	struct tty_ldisc *ld;	2174	struct tty_ldisc *ld;
2175	int ret = 0;	2175	int ret = 0;
2176		2176
2177	if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))	2177	if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))
2178	return 0;	2178	return 0;
2179		2179
2180	ld = tty_ldisc_ref_wait(tty);	2180	ld = tty_ldisc_ref_wait(tty);
2181	if (ld->ops->poll)	2181	if (ld->ops->poll)
2182	ret = ld->ops->poll(tty, filp, wait);	2182	ret = ld->ops->poll(tty, filp, wait);
2183	tty_ldisc_deref(ld);	2183	tty_ldisc_deref(ld);
2184	return ret;	2184	return ret;
2185	}	2185	}
2186		2186
2187	static int __tty_fasync(int fd, struct file *filp, int on)	2187	static int __tty_fasync(int fd, struct file *filp, int on)
2188	{	2188	{
2189	struct tty_struct *tty = file_tty(filp);	2189	struct tty_struct *tty = file_tty(filp);
2190	struct tty_ldisc *ldisc;	2190	struct tty_ldisc *ldisc;
2191	unsigned long flags;	2191	unsigned long flags;
2192	int retval = 0;	2192	int retval = 0;
2193		2193
2194	if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))	2194	if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
2195	goto out;	2195	goto out;
2196		2196
2197	retval = fasync_helper(fd, filp, on, &tty->fasync);	2197	retval = fasync_helper(fd, filp, on, &tty->fasync);
2198	if (retval <= 0)	2198	if (retval <= 0)
2199	goto out;	2199	goto out;
2200		2200
2201	ldisc = tty_ldisc_ref(tty);	2201	ldisc = tty_ldisc_ref(tty);
2202	if (ldisc) {	2202	if (ldisc) {
2203	if (ldisc->ops->fasync)	2203	if (ldisc->ops->fasync)
2204	ldisc->ops->fasync(tty, on);	2204	ldisc->ops->fasync(tty, on);
2205	tty_ldisc_deref(ldisc);	2205	tty_ldisc_deref(ldisc);
2206	}	2206	}
2207		2207
2208	if (on) {	2208	if (on) {
2209	enum pid_type type;	2209	enum pid_type type;
2210	struct pid *pid;	2210	struct pid *pid;
2211		2211
2212	spin_lock_irqsave(&tty->ctrl_lock, flags);	2212	spin_lock_irqsave(&tty->ctrl_lock, flags);
2213	if (tty->pgrp) {	2213	if (tty->pgrp) {
2214	pid = tty->pgrp;	2214	pid = tty->pgrp;
2215	type = PIDTYPE_PGID;	2215	type = PIDTYPE_PGID;
2216	} else {	2216	} else {
2217	pid = task_pid(current);	2217	pid = task_pid(current);
2218	type = PIDTYPE_PID;	2218	type = PIDTYPE_PID;
2219	}	2219	}
2220	get_pid(pid);	2220	get_pid(pid);
2221	spin_unlock_irqrestore(&tty->ctrl_lock, flags);	2221	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2222	__f_setown(filp, pid, type, 0);	2222	__f_setown(filp, pid, type, 0);
2223	put_pid(pid);	2223	put_pid(pid);
2224	retval = 0;	2224	retval = 0;
2225	}	2225	}
2226	out:	2226	out:
2227	return retval;	2227	return retval;
2228	}	2228	}
2229		2229
2230	static int tty_fasync(int fd, struct file *filp, int on)	2230	static int tty_fasync(int fd, struct file *filp, int on)
2231	{	2231	{
2232	struct tty_struct *tty = file_tty(filp);	2232	struct tty_struct *tty = file_tty(filp);
2233	int retval;	2233	int retval;
2234		2234
2235	tty_lock(tty);	2235	tty_lock(tty);
2236	retval = __tty_fasync(fd, filp, on);	2236	retval = __tty_fasync(fd, filp, on);
2237	tty_unlock(tty);	2237	tty_unlock(tty);
2238		2238
2239	return retval;	2239	return retval;
2240	}	2240	}
2241		2241
2242	/**	2242	/**
2243	* tiocsti - fake input character	2243	* tiocsti - fake input character
2244	* @tty: tty to fake input into	2244	* @tty: tty to fake input into
2245	* @p: pointer to character	2245	* @p: pointer to character
2246	*	2246	*
2247	* Fake input to a tty device. Does the necessary locking and	2247	* Fake input to a tty device. Does the necessary locking and
2248	* input management.	2248	* input management.
2249	*	2249	*
2250	* FIXME: does not honour flow control ??	2250	* FIXME: does not honour flow control ??
2251	*	2251	*
2252	* Locking:	2252	* Locking:
2253	* Called functions take tty_ldiscs_lock	2253	* Called functions take tty_ldiscs_lock
2254	* current->signal->tty check is safe without locks	2254	* current->signal->tty check is safe without locks
2255	*	2255	*
2256	* FIXME: may race normal receive processing	2256	* FIXME: may race normal receive processing
2257	*/	2257	*/
2258		2258
2259	static int tiocsti(struct tty_struct tty, char __user p)	2259	static int tiocsti(struct tty_struct tty, char __user p)
2260	{	2260	{
2261	char ch, mbz = 0;	2261	char ch, mbz = 0;
2262	struct tty_ldisc *ld;	2262	struct tty_ldisc *ld;
2263		2263
2264	if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))	2264	if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2265	return -EPERM;	2265	return -EPERM;
2266	if (get_user(ch, p))	2266	if (get_user(ch, p))
2267	return -EFAULT;	2267	return -EFAULT;
2268	tty_audit_tiocsti(tty, ch);	2268	tty_audit_tiocsti(tty, ch);
2269	ld = tty_ldisc_ref_wait(tty);	2269	ld = tty_ldisc_ref_wait(tty);
2270	ld->ops->receive_buf(tty, &ch, &mbz, 1);	2270	ld->ops->receive_buf(tty, &ch, &mbz, 1);
2271	tty_ldisc_deref(ld);	2271	tty_ldisc_deref(ld);
2272	return 0;	2272	return 0;
2273	}	2273	}
2274		2274
2275	/**	2275	/**
2276	* tiocgwinsz - implement window query ioctl	2276	* tiocgwinsz - implement window query ioctl
2277	* @tty; tty	2277	* @tty; tty
2278	* @arg: user buffer for result	2278	* @arg: user buffer for result
2279	*	2279	*
2280	* Copies the kernel idea of the window size into the user buffer.	2280	* Copies the kernel idea of the window size into the user buffer.
2281	*	2281	*
2282	* Locking: tty->winsize_mutex is taken to ensure the winsize data	2282	* Locking: tty->winsize_mutex is taken to ensure the winsize data
2283	* is consistent.	2283	* is consistent.
2284	*/	2284	*/
2285		2285
2286	static int tiocgwinsz(struct tty_struct tty, struct winsize __user arg)	2286	static int tiocgwinsz(struct tty_struct tty, struct winsize __user arg)
2287	{	2287	{
2288	int err;	2288	int err;
2289		2289
2290	mutex_lock(&tty->winsize_mutex);	2290	mutex_lock(&tty->winsize_mutex);
2291	err = copy_to_user(arg, &tty->winsize, sizeof(*arg));	2291	err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2292	mutex_unlock(&tty->winsize_mutex);	2292	mutex_unlock(&tty->winsize_mutex);
2293		2293
2294	return err ? -EFAULT: 0;	2294	return err ? -EFAULT: 0;
2295	}	2295	}
2296		2296
2297	/**	2297	/**
2298	* tty_do_resize - resize event	2298	* tty_do_resize - resize event
2299	* @tty: tty being resized	2299	* @tty: tty being resized
2300	* @rows: rows (character)	2300	* @rows: rows (character)
2301	* @cols: cols (character)	2301	* @cols: cols (character)
2302	*	2302	*
2303	* Update the termios variables and send the necessary signals to	2303	* Update the termios variables and send the necessary signals to
2304	* peform a terminal resize correctly	2304	* peform a terminal resize correctly
2305	*/	2305	*/
2306		2306
2307	int tty_do_resize(struct tty_struct tty, struct winsize ws)	2307	int tty_do_resize(struct tty_struct tty, struct winsize ws)
2308	{	2308	{
2309	struct pid *pgrp;	2309	struct pid *pgrp;
2310		2310
2311	/* Lock the tty */	2311	/* Lock the tty */
2312	mutex_lock(&tty->winsize_mutex);	2312	mutex_lock(&tty->winsize_mutex);
2313	if (!memcmp(ws, &tty->winsize, sizeof(*ws)))	2313	if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
2314	goto done;	2314	goto done;
2315		2315
2316	/* Signal the foreground process group */	2316	/* Signal the foreground process group */
2317	pgrp = tty_get_pgrp(tty);	2317	pgrp = tty_get_pgrp(tty);
2318	if (pgrp)	2318	if (pgrp)
2319	kill_pgrp(pgrp, SIGWINCH, 1);	2319	kill_pgrp(pgrp, SIGWINCH, 1);
2320	put_pid(pgrp);	2320	put_pid(pgrp);
2321		2321
2322	tty->winsize = *ws;	2322	tty->winsize = *ws;
2323	done:	2323	done:
2324	mutex_unlock(&tty->winsize_mutex);	2324	mutex_unlock(&tty->winsize_mutex);
2325	return 0;	2325	return 0;
2326	}	2326	}
2327	EXPORT_SYMBOL(tty_do_resize);	2327	EXPORT_SYMBOL(tty_do_resize);
2328		2328
2329	/**	2329	/**
2330	* tiocswinsz - implement window size set ioctl	2330	* tiocswinsz - implement window size set ioctl
2331	* @tty; tty side of tty	2331	* @tty; tty side of tty
2332	* @arg: user buffer for result	2332	* @arg: user buffer for result
2333	*	2333	*
2334	* Copies the user idea of the window size to the kernel. Traditionally	2334	* Copies the user idea of the window size to the kernel. Traditionally
2335	* this is just advisory information but for the Linux console it	2335	* this is just advisory information but for the Linux console it
2336	* actually has driver level meaning and triggers a VC resize.	2336	* actually has driver level meaning and triggers a VC resize.
2337	*	2337	*
2338	* Locking:	2338	* Locking:
2339	* Driver dependent. The default do_resize method takes the	2339	* Driver dependent. The default do_resize method takes the
2340	* tty termios mutex and ctrl_lock. The console takes its own lock	2340	* tty termios mutex and ctrl_lock. The console takes its own lock
2341	* then calls into the default method.	2341	* then calls into the default method.
2342	*/	2342	*/
2343		2343
2344	static int tiocswinsz(struct tty_struct tty, struct winsize __user arg)	2344	static int tiocswinsz(struct tty_struct tty, struct winsize __user arg)
2345	{	2345	{
2346	struct winsize tmp_ws;	2346	struct winsize tmp_ws;
2347	if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))	2347	if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2348	return -EFAULT;	2348	return -EFAULT;
2349		2349
2350	if (tty->ops->resize)	2350	if (tty->ops->resize)
2351	return tty->ops->resize(tty, &tmp_ws);	2351	return tty->ops->resize(tty, &tmp_ws);
2352	else	2352	else
2353	return tty_do_resize(tty, &tmp_ws);	2353	return tty_do_resize(tty, &tmp_ws);
2354	}	2354	}
2355		2355
2356	/**	2356	/**
2357	* tioccons - allow admin to move logical console	2357	* tioccons - allow admin to move logical console
2358	* @file: the file to become console	2358	* @file: the file to become console
2359	*	2359	*
2360	* Allow the administrator to move the redirected console device	2360	* Allow the administrator to move the redirected console device
2361	*	2361	*
2362	* Locking: uses redirect_lock to guard the redirect information	2362	* Locking: uses redirect_lock to guard the redirect information
2363	*/	2363	*/
2364		2364
2365	static int tioccons(struct file *file)	2365	static int tioccons(struct file *file)
2366	{	2366	{
2367	if (!capable(CAP_SYS_ADMIN))	2367	if (!capable(CAP_SYS_ADMIN))
2368	return -EPERM;	2368	return -EPERM;
2369	if (file->f_op->write == redirected_tty_write) {	2369	if (file->f_op->write == redirected_tty_write) {
2370	struct file *f;	2370	struct file *f;
2371	spin_lock(&redirect_lock);	2371	spin_lock(&redirect_lock);
2372	f = redirect;	2372	f = redirect;
2373	redirect = NULL;	2373	redirect = NULL;
2374	spin_unlock(&redirect_lock);	2374	spin_unlock(&redirect_lock);
2375	if (f)	2375	if (f)
2376	fput(f);	2376	fput(f);
2377	return 0;	2377	return 0;
2378	}	2378	}
2379	spin_lock(&redirect_lock);	2379	spin_lock(&redirect_lock);
2380	if (redirect) {	2380	if (redirect) {
2381	spin_unlock(&redirect_lock);	2381	spin_unlock(&redirect_lock);
2382	return -EBUSY;	2382	return -EBUSY;
2383	}	2383	}
2384	redirect = get_file(file);	2384	redirect = get_file(file);
2385	spin_unlock(&redirect_lock);	2385	spin_unlock(&redirect_lock);
2386	return 0;	2386	return 0;
2387	}	2387	}
2388		2388
2389	/**	2389	/**
2390	* fionbio - non blocking ioctl	2390	* fionbio - non blocking ioctl
2391	* @file: file to set blocking value	2391	* @file: file to set blocking value
2392	* @p: user parameter	2392	* @p: user parameter
2393	*	2393	*
2394	* Historical tty interfaces had a blocking control ioctl before	2394	* Historical tty interfaces had a blocking control ioctl before
2395	* the generic functionality existed. This piece of history is preserved	2395	* the generic functionality existed. This piece of history is preserved
2396	* in the expected tty API of posix OS's.	2396	* in the expected tty API of posix OS's.
2397	*	2397	*
2398	* Locking: none, the open file handle ensures it won't go away.	2398	* Locking: none, the open file handle ensures it won't go away.
2399	*/	2399	*/
2400		2400
2401	static int fionbio(struct file file, int __user p)	2401	static int fionbio(struct file file, int __user p)
2402	{	2402	{
2403	int nonblock;	2403	int nonblock;
2404		2404
2405	if (get_user(nonblock, p))	2405	if (get_user(nonblock, p))
2406	return -EFAULT;	2406	return -EFAULT;
2407		2407
2408	spin_lock(&file->f_lock);	2408	spin_lock(&file->f_lock);
2409	if (nonblock)	2409	if (nonblock)
2410	file->f_flags \|= O_NONBLOCK;	2410	file->f_flags \|= O_NONBLOCK;
2411	else	2411	else
2412	file->f_flags &= ~O_NONBLOCK;	2412	file->f_flags &= ~O_NONBLOCK;
2413	spin_unlock(&file->f_lock);	2413	spin_unlock(&file->f_lock);
2414	return 0;	2414	return 0;
2415	}	2415	}
2416		2416
2417	/**	2417	/**
2418	* tiocsctty - set controlling tty	2418	* tiocsctty - set controlling tty
2419	* @tty: tty structure	2419	* @tty: tty structure
2420	* @arg: user argument	2420	* @arg: user argument
2421	*	2421	*
2422	* This ioctl is used to manage job control. It permits a session	2422	* This ioctl is used to manage job control. It permits a session
2423	* leader to set this tty as the controlling tty for the session.	2423	* leader to set this tty as the controlling tty for the session.
2424	*	2424	*
2425	* Locking:	2425	* Locking:
2426	* Takes tty_lock() to serialize proc_set_tty() for this tty	2426	* Takes tty_lock() to serialize proc_set_tty() for this tty
2427	* Takes tasklist_lock internally to walk sessions	2427	* Takes tasklist_lock internally to walk sessions
2428	* Takes ->siglock() when updating signal->tty	2428	* Takes ->siglock() when updating signal->tty
2429	*/	2429	*/
2430		2430
2431	static int tiocsctty(struct tty_struct *tty, int arg)	2431	static int tiocsctty(struct tty_struct *tty, int arg)
2432	{	2432	{
2433	int ret = 0;	2433	int ret = 0;
2434		2434
2435	tty_lock(tty);	2435	tty_lock(tty);
2436	read_lock(&tasklist_lock);	2436	read_lock(&tasklist_lock);
2437		2437
2438	if (current->signal->leader && (task_session(current) == tty->session))	2438	if (current->signal->leader && (task_session(current) == tty->session))
2439	goto unlock;	2439	goto unlock;
2440		2440
2441	/*	2441	/*
2442	* The process must be a session leader and	2442	* The process must be a session leader and
2443	* not have a controlling tty already.	2443	* not have a controlling tty already.
2444	*/	2444	*/
2445	if (!current->signal->leader \|\| current->signal->tty) {	2445	if (!current->signal->leader \|\| current->signal->tty) {
2446	ret = -EPERM;	2446	ret = -EPERM;
2447	goto unlock;	2447	goto unlock;
2448	}	2448	}
2449		2449
2450	if (tty->session) {	2450	if (tty->session) {
2451	/*	2451	/*
2452	* This tty is already the controlling	2452	* This tty is already the controlling
2453	* tty for another session group!	2453	* tty for another session group!
2454	*/	2454	*/
2455	if (arg == 1 && capable(CAP_SYS_ADMIN)) {	2455	if (arg == 1 && capable(CAP_SYS_ADMIN)) {
2456	/*	2456	/*
2457	* Steal it away	2457	* Steal it away
2458	*/	2458	*/
2459	session_clear_tty(tty->session);	2459	session_clear_tty(tty->session);
2460	} else {	2460	} else {
2461	ret = -EPERM;	2461	ret = -EPERM;
2462	goto unlock;	2462	goto unlock;
2463	}	2463	}
2464	}	2464	}
2465	proc_set_tty(tty);	2465	proc_set_tty(tty);
2466	unlock:	2466	unlock:
2467	read_unlock(&tasklist_lock);	2467	read_unlock(&tasklist_lock);
2468	tty_unlock(tty);	2468	tty_unlock(tty);
2469	return ret;	2469	return ret;
2470	}	2470	}
2471		2471
2472	/**	2472	/**
2473	* tty_get_pgrp - return a ref counted pgrp pid	2473	* tty_get_pgrp - return a ref counted pgrp pid
2474	* @tty: tty to read	2474	* @tty: tty to read
2475	*	2475	*
2476	* Returns a refcounted instance of the pid struct for the process	2476	* Returns a refcounted instance of the pid struct for the process
2477	* group controlling the tty.	2477	* group controlling the tty.
2478	*/	2478	*/
2479		2479
2480	struct pid tty_get_pgrp(struct tty_struct tty)	2480	struct pid tty_get_pgrp(struct tty_struct tty)
2481	{	2481	{
2482	unsigned long flags;	2482	unsigned long flags;
2483	struct pid *pgrp;	2483	struct pid *pgrp;
2484		2484
2485	spin_lock_irqsave(&tty->ctrl_lock, flags);	2485	spin_lock_irqsave(&tty->ctrl_lock, flags);
2486	pgrp = get_pid(tty->pgrp);	2486	pgrp = get_pid(tty->pgrp);
2487	spin_unlock_irqrestore(&tty->ctrl_lock, flags);	2487	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2488		2488
2489	return pgrp;	2489	return pgrp;
2490	}	2490	}
2491	EXPORT_SYMBOL_GPL(tty_get_pgrp);	2491	EXPORT_SYMBOL_GPL(tty_get_pgrp);
2492		2492
2493	/*	2493	/*
2494	* This checks not only the pgrp, but falls back on the pid if no	2494	* This checks not only the pgrp, but falls back on the pid if no
2495	* satisfactory pgrp is found. I dunno - gdb doesn't work correctly	2495	* satisfactory pgrp is found. I dunno - gdb doesn't work correctly
2496	* without this...	2496	* without this...
2497	*	2497	*
2498	* The caller must hold rcu lock or the tasklist lock.	2498	* The caller must hold rcu lock or the tasklist lock.
2499	*/	2499	*/
2500	static struct pid session_of_pgrp(struct pid pgrp)	2500	static struct pid session_of_pgrp(struct pid pgrp)
2501	{	2501	{
2502	struct task_struct *p;	2502	struct task_struct *p;
2503	struct pid *sid = NULL;	2503	struct pid *sid = NULL;
2504		2504
2505	p = pid_task(pgrp, PIDTYPE_PGID);	2505	p = pid_task(pgrp, PIDTYPE_PGID);
2506	if (p == NULL)	2506	if (p == NULL)
2507	p = pid_task(pgrp, PIDTYPE_PID);	2507	p = pid_task(pgrp, PIDTYPE_PID);
2508	if (p != NULL)	2508	if (p != NULL)
2509	sid = task_session(p);	2509	sid = task_session(p);
2510		2510
2511	return sid;	2511	return sid;
2512	}	2512	}
2513		2513
2514	/**	2514	/**
2515	* tiocgpgrp - get process group	2515	* tiocgpgrp - get process group
2516	* @tty: tty passed by user	2516	* @tty: tty passed by user
2517	* @real_tty: tty side of the tty passed by the user if a pty else the tty	2517	* @real_tty: tty side of the tty passed by the user if a pty else the tty
2518	* @p: returned pid	2518	* @p: returned pid
2519	*	2519	*
2520	* Obtain the process group of the tty. If there is no process group	2520	* Obtain the process group of the tty. If there is no process group
2521	* return an error.	2521	* return an error.
2522	*	2522	*
2523	* Locking: none. Reference to current->signal->tty is safe.	2523	* Locking: none. Reference to current->signal->tty is safe.
2524	*/	2524	*/
2525		2525
2526	static int tiocgpgrp(struct tty_struct tty, struct tty_struct real_tty, pid_t __user *p)	2526	static int tiocgpgrp(struct tty_struct tty, struct tty_struct real_tty, pid_t __user *p)
2527	{	2527	{
2528	struct pid *pid;	2528	struct pid *pid;
2529	int ret;	2529	int ret;
2530	/*	2530	/*
2531	* (tty == real_tty) is a cheap way of	2531	* (tty == real_tty) is a cheap way of
2532	* testing if the tty is NOT a master pty.	2532	* testing if the tty is NOT a master pty.
2533	*/	2533	*/
2534	if (tty == real_tty && current->signal->tty != real_tty)	2534	if (tty == real_tty && current->signal->tty != real_tty)
2535	return -ENOTTY;	2535	return -ENOTTY;
2536	pid = tty_get_pgrp(real_tty);	2536	pid = tty_get_pgrp(real_tty);
2537	ret = put_user(pid_vnr(pid), p);	2537	ret = put_user(pid_vnr(pid), p);
2538	put_pid(pid);	2538	put_pid(pid);
2539	return ret;	2539	return ret;
2540	}	2540	}
2541		2541
2542	/**	2542	/**
2543	* tiocspgrp - attempt to set process group	2543	* tiocspgrp - attempt to set process group
2544	* @tty: tty passed by user	2544	* @tty: tty passed by user
2545	* @real_tty: tty side device matching tty passed by user	2545	* @real_tty: tty side device matching tty passed by user
2546	* @p: pid pointer	2546	* @p: pid pointer
2547	*	2547	*
2548	* Set the process group of the tty to the session passed. Only	2548	* Set the process group of the tty to the session passed. Only
2549	* permitted where the tty session is our session.	2549	* permitted where the tty session is our session.
2550	*	2550	*
2551	* Locking: RCU, ctrl lock	2551	* Locking: RCU, ctrl lock
2552	*/	2552	*/
2553		2553
2554	static int tiocspgrp(struct tty_struct tty, struct tty_struct real_tty, pid_t __user *p)	2554	static int tiocspgrp(struct tty_struct tty, struct tty_struct real_tty, pid_t __user *p)
2555	{	2555	{
2556	struct pid *pgrp;	2556	struct pid *pgrp;
2557	pid_t pgrp_nr;	2557	pid_t pgrp_nr;
2558	int retval = tty_check_change(real_tty);	2558	int retval = tty_check_change(real_tty);
2559	unsigned long flags;	2559	unsigned long flags;
2560		2560
2561	if (retval == -EIO)	2561	if (retval == -EIO)
2562	return -ENOTTY;	2562	return -ENOTTY;
2563	if (retval)	2563	if (retval)
2564	return retval;	2564	return retval;
2565	if (!current->signal->tty \|\|	2565	if (!current->signal->tty \|\|
2566	(current->signal->tty != real_tty) \|\|	2566	(current->signal->tty != real_tty) \|\|
2567	(real_tty->session != task_session(current)))	2567	(real_tty->session != task_session(current)))
2568	return -ENOTTY;	2568	return -ENOTTY;
2569	if (get_user(pgrp_nr, p))	2569	if (get_user(pgrp_nr, p))
2570	return -EFAULT;	2570	return -EFAULT;
2571	if (pgrp_nr < 0)	2571	if (pgrp_nr < 0)
2572	return -EINVAL;	2572	return -EINVAL;
2573	rcu_read_lock();	2573	rcu_read_lock();
2574	pgrp = find_vpid(pgrp_nr);	2574	pgrp = find_vpid(pgrp_nr);
2575	retval = -ESRCH;	2575	retval = -ESRCH;
2576	if (!pgrp)	2576	if (!pgrp)
2577	goto out_unlock;	2577	goto out_unlock;
2578	retval = -EPERM;	2578	retval = -EPERM;
2579	if (session_of_pgrp(pgrp) != task_session(current))	2579	if (session_of_pgrp(pgrp) != task_session(current))
2580	goto out_unlock;	2580	goto out_unlock;
2581	retval = 0;	2581	retval = 0;
2582	spin_lock_irqsave(&tty->ctrl_lock, flags);	2582	spin_lock_irqsave(&tty->ctrl_lock, flags);
2583	put_pid(real_tty->pgrp);	2583	put_pid(real_tty->pgrp);
2584	real_tty->pgrp = get_pid(pgrp);	2584	real_tty->pgrp = get_pid(pgrp);
2585	spin_unlock_irqrestore(&tty->ctrl_lock, flags);	2585	spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2586	out_unlock:	2586	out_unlock:
2587	rcu_read_unlock();	2587	rcu_read_unlock();
2588	return retval;	2588	return retval;
2589	}	2589	}
2590		2590
2591	/**	2591	/**
2592	* tiocgsid - get session id	2592	* tiocgsid - get session id
2593	* @tty: tty passed by user	2593	* @tty: tty passed by user
2594	* @real_tty: tty side of the tty passed by the user if a pty else the tty	2594	* @real_tty: tty side of the tty passed by the user if a pty else the tty
2595	* @p: pointer to returned session id	2595	* @p: pointer to returned session id
2596	*	2596	*
2597	* Obtain the session id of the tty. If there is no session	2597	* Obtain the session id of the tty. If there is no session
2598	* return an error.	2598	* return an error.
2599	*	2599	*
2600	* Locking: none. Reference to current->signal->tty is safe.	2600	* Locking: none. Reference to current->signal->tty is safe.
2601	*/	2601	*/
2602		2602
2603	static int tiocgsid(struct tty_struct tty, struct tty_struct real_tty, pid_t __user *p)	2603	static int tiocgsid(struct tty_struct tty, struct tty_struct real_tty, pid_t __user *p)
2604	{	2604	{
2605	/*	2605	/*
2606	* (tty == real_tty) is a cheap way of	2606	* (tty == real_tty) is a cheap way of
2607	* testing if the tty is NOT a master pty.	2607	* testing if the tty is NOT a master pty.
2608	*/	2608	*/
2609	if (tty == real_tty && current->signal->tty != real_tty)	2609	if (tty == real_tty && current->signal->tty != real_tty)
2610	return -ENOTTY;	2610	return -ENOTTY;
2611	if (!real_tty->session)	2611	if (!real_tty->session)
2612	return -ENOTTY;	2612	return -ENOTTY;
2613	return put_user(pid_vnr(real_tty->session), p);	2613	return put_user(pid_vnr(real_tty->session), p);
2614	}	2614	}
2615		2615
2616	/**	2616	/**
2617	* tiocsetd - set line discipline	2617	* tiocsetd - set line discipline
2618	* @tty: tty device	2618	* @tty: tty device
2619	* @p: pointer to user data	2619	* @p: pointer to user data
2620	*	2620	*
2621	* Set the line discipline according to user request.	2621	* Set the line discipline according to user request.
2622	*	2622	*
2623	* Locking: see tty_set_ldisc, this function is just a helper	2623	* Locking: see tty_set_ldisc, this function is just a helper
2624	*/	2624	*/
2625		2625
2626	static int tiocsetd(struct tty_struct tty, int __user p)	2626	static int tiocsetd(struct tty_struct tty, int __user p)
2627	{	2627	{
2628	int ldisc;	2628	int ldisc;
2629	int ret;	2629	int ret;
2630		2630
2631	if (get_user(ldisc, p))	2631	if (get_user(ldisc, p))
2632	return -EFAULT;	2632	return -EFAULT;
2633		2633
2634	ret = tty_set_ldisc(tty, ldisc);	2634	ret = tty_set_ldisc(tty, ldisc);
2635		2635
2636	return ret;	2636	return ret;
2637	}	2637	}
2638		2638
2639	/**	2639	/**
2640	* send_break - performed time break	2640	* send_break - performed time break
2641	* @tty: device to break on	2641	* @tty: device to break on
2642	* @duration: timeout in mS	2642	* @duration: timeout in mS
2643	*	2643	*
2644	* Perform a timed break on hardware that lacks its own driver level	2644	* Perform a timed break on hardware that lacks its own driver level
2645	* timed break functionality.	2645	* timed break functionality.
2646	*	2646	*
2647	* Locking:	2647	* Locking:
2648	* atomic_write_lock serializes	2648	* atomic_write_lock serializes
2649	*	2649	*
2650	*/	2650	*/
2651		2651
2652	static int send_break(struct tty_struct *tty, unsigned int duration)	2652	static int send_break(struct tty_struct *tty, unsigned int duration)
2653	{	2653	{
2654	int retval;	2654	int retval;
2655		2655
2656	if (tty->ops->break_ctl == NULL)	2656	if (tty->ops->break_ctl == NULL)
2657	return 0;	2657	return 0;
2658		2658
2659	if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)	2659	if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2660	retval = tty->ops->break_ctl(tty, duration);	2660	retval = tty->ops->break_ctl(tty, duration);
2661	else {	2661	else {
2662	/* Do the work ourselves */	2662	/* Do the work ourselves */
2663	if (tty_write_lock(tty, 0) < 0)	2663	if (tty_write_lock(tty, 0) < 0)
2664	return -EINTR;	2664	return -EINTR;
2665	retval = tty->ops->break_ctl(tty, -1);	2665	retval = tty->ops->break_ctl(tty, -1);
2666	if (retval)	2666	if (retval)
2667	goto out;	2667	goto out;
2668	if (!signal_pending(current))	2668	if (!signal_pending(current))
2669	msleep_interruptible(duration);	2669	msleep_interruptible(duration);
2670	retval = tty->ops->break_ctl(tty, 0);	2670	retval = tty->ops->break_ctl(tty, 0);
2671	out:	2671	out:
2672	tty_write_unlock(tty);	2672	tty_write_unlock(tty);
2673	if (signal_pending(current))	2673	if (signal_pending(current))
2674	retval = -EINTR;	2674	retval = -EINTR;
2675	}	2675	}
2676	return retval;	2676	return retval;
2677	}	2677	}
2678		2678
2679	/**	2679	/**
2680	* tty_tiocmget - get modem status	2680	* tty_tiocmget - get modem status
2681	* @tty: tty device	2681	* @tty: tty device
2682	* @file: user file pointer	2682	* @file: user file pointer
2683	* @p: pointer to result	2683	* @p: pointer to result
2684	*	2684	*
2685	* Obtain the modem status bits from the tty driver if the feature	2685	* Obtain the modem status bits from the tty driver if the feature
2686	* is supported. Return -EINVAL if it is not available.	2686	* is supported. Return -EINVAL if it is not available.
2687	*	2687	*
2688	* Locking: none (up to the driver)	2688	* Locking: none (up to the driver)
2689	*/	2689	*/
2690		2690
2691	static int tty_tiocmget(struct tty_struct tty, int __user p)	2691	static int tty_tiocmget(struct tty_struct tty, int __user p)
2692	{	2692	{
2693	int retval = -EINVAL;	2693	int retval = -EINVAL;
2694		2694
2695	if (tty->ops->tiocmget) {	2695	if (tty->ops->tiocmget) {
2696	retval = tty->ops->tiocmget(tty);	2696	retval = tty->ops->tiocmget(tty);
2697		2697
2698	if (retval >= 0)	2698	if (retval >= 0)
2699	retval = put_user(retval, p);	2699	retval = put_user(retval, p);
2700	}	2700	}
2701	return retval;	2701	return retval;
2702	}	2702	}
2703		2703
2704	/**	2704	/**
2705	* tty_tiocmset - set modem status	2705	* tty_tiocmset - set modem status
2706	* @tty: tty device	2706	* @tty: tty device
2707	* @cmd: command - clear bits, set bits or set all	2707	* @cmd: command - clear bits, set bits or set all
2708	* @p: pointer to desired bits	2708	* @p: pointer to desired bits
2709	*	2709	*
2710	* Set the modem status bits from the tty driver if the feature	2710	* Set the modem status bits from the tty driver if the feature
2711	* is supported. Return -EINVAL if it is not available.	2711	* is supported. Return -EINVAL if it is not available.
2712	*	2712	*
2713	* Locking: none (up to the driver)	2713	* Locking: none (up to the driver)
2714	*/	2714	*/
2715		2715
2716	static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,	2716	static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
2717	unsigned __user *p)	2717	unsigned __user *p)
2718	{	2718	{
2719	int retval;	2719	int retval;
2720	unsigned int set, clear, val;	2720	unsigned int set, clear, val;
2721		2721
2722	if (tty->ops->tiocmset == NULL)	2722	if (tty->ops->tiocmset == NULL)
2723	return -EINVAL;	2723	return -EINVAL;
2724		2724
2725	retval = get_user(val, p);	2725	retval = get_user(val, p);
2726	if (retval)	2726	if (retval)
2727	return retval;	2727	return retval;
2728	set = clear = 0;	2728	set = clear = 0;
2729	switch (cmd) {	2729	switch (cmd) {
2730	case TIOCMBIS:	2730	case TIOCMBIS:
2731	set = val;	2731	set = val;
2732	break;	2732	break;
2733	case TIOCMBIC:	2733	case TIOCMBIC:
2734	clear = val;	2734	clear = val;
2735	break;	2735	break;
2736	case TIOCMSET:	2736	case TIOCMSET:
2737	set = val;	2737	set = val;
2738	clear = ~val;	2738	clear = ~val;
2739	break;	2739	break;
2740	}	2740	}
2741	set &= TIOCM_DTR\|TIOCM_RTS\|TIOCM_OUT1\|TIOCM_OUT2\|TIOCM_LOOP;	2741	set &= TIOCM_DTR\|TIOCM_RTS\|TIOCM_OUT1\|TIOCM_OUT2\|TIOCM_LOOP;
2742	clear &= TIOCM_DTR\|TIOCM_RTS\|TIOCM_OUT1\|TIOCM_OUT2\|TIOCM_LOOP;	2742	clear &= TIOCM_DTR\|TIOCM_RTS\|TIOCM_OUT1\|TIOCM_OUT2\|TIOCM_LOOP;
2743	return tty->ops->tiocmset(tty, set, clear);	2743	return tty->ops->tiocmset(tty, set, clear);
2744	}	2744	}
2745		2745
2746	static int tty_tiocgicount(struct tty_struct tty, void __user arg)	2746	static int tty_tiocgicount(struct tty_struct tty, void __user arg)
2747	{	2747	{
2748	int retval = -EINVAL;	2748	int retval = -EINVAL;
2749	struct serial_icounter_struct icount;	2749	struct serial_icounter_struct icount;
2750	memset(&icount, 0, sizeof(icount));	2750	memset(&icount, 0, sizeof(icount));
2751	if (tty->ops->get_icount)	2751	if (tty->ops->get_icount)
2752	retval = tty->ops->get_icount(tty, &icount);	2752	retval = tty->ops->get_icount(tty, &icount);
2753	if (retval != 0)	2753	if (retval != 0)
2754	return retval;	2754	return retval;
2755	if (copy_to_user(arg, &icount, sizeof(icount)))	2755	if (copy_to_user(arg, &icount, sizeof(icount)))
2756	return -EFAULT;	2756	return -EFAULT;
2757	return 0;	2757	return 0;
2758	}	2758	}
2759		2759
2760	static void tty_warn_deprecated_flags(struct serial_struct __user *ss)	2760	static void tty_warn_deprecated_flags(struct serial_struct __user *ss)
2761	{	2761	{
2762	static DEFINE_RATELIMIT_STATE(depr_flags,	2762	static DEFINE_RATELIMIT_STATE(depr_flags,
2763	DEFAULT_RATELIMIT_INTERVAL,	2763	DEFAULT_RATELIMIT_INTERVAL,
2764	DEFAULT_RATELIMIT_BURST);	2764	DEFAULT_RATELIMIT_BURST);
2765	char comm[TASK_COMM_LEN];	2765	char comm[TASK_COMM_LEN];
2766	int flags;	2766	int flags;
2767		2767
2768	if (get_user(flags, &ss->flags))	2768	if (get_user(flags, &ss->flags))
2769	return;	2769	return;
2770		2770
2771	flags &= ASYNC_DEPRECATED;	2771	flags &= ASYNC_DEPRECATED;
2772		2772
2773	if (flags && __ratelimit(&depr_flags))	2773	if (flags && __ratelimit(&depr_flags))
2774	pr_warning("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",	2774	pr_warning("%s: '%s' is using deprecated serial flags (with no effect): %.8x\n",
2775	__func__, get_task_comm(comm, current), flags);	2775	__func__, get_task_comm(comm, current), flags);
2776	}	2776	}
2777		2777
2778	/*	2778	/*
2779	* if pty, return the slave side (real_tty)	2779	* if pty, return the slave side (real_tty)
2780	* otherwise, return self	2780	* otherwise, return self
2781	*/	2781	*/
2782	static struct tty_struct tty_pair_get_tty(struct tty_struct tty)	2782	static struct tty_struct tty_pair_get_tty(struct tty_struct tty)
2783	{	2783	{
2784	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&	2784	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2785	tty->driver->subtype == PTY_TYPE_MASTER)	2785	tty->driver->subtype == PTY_TYPE_MASTER)
2786	tty = tty->link;	2786	tty = tty->link;
2787	return tty;	2787	return tty;
2788	}	2788	}
2789		2789
2790	/*	2790	/*
2791	* Split this up, as gcc can choke on it otherwise..	2791	* Split this up, as gcc can choke on it otherwise..
2792	*/	2792	*/
2793	long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)	2793	long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2794	{	2794	{
2795	struct tty_struct *tty = file_tty(file);	2795	struct tty_struct *tty = file_tty(file);
2796	struct tty_struct *real_tty;	2796	struct tty_struct *real_tty;
2797	void __user p = (void __user )arg;	2797	void __user p = (void __user )arg;
2798	int retval;	2798	int retval;
2799	struct tty_ldisc *ld;	2799	struct tty_ldisc *ld;
2800		2800
2801	if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))	2801	if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
2802	return -EINVAL;	2802	return -EINVAL;
2803		2803
2804	real_tty = tty_pair_get_tty(tty);	2804	real_tty = tty_pair_get_tty(tty);
2805		2805
2806	/*	2806	/*
2807	* Factor out some common prep work	2807	* Factor out some common prep work
2808	*/	2808	*/
2809	switch (cmd) {	2809	switch (cmd) {
2810	case TIOCSETD:	2810	case TIOCSETD:
2811	case TIOCSBRK:	2811	case TIOCSBRK:
2812	case TIOCCBRK:	2812	case TIOCCBRK:
2813	case TCSBRK:	2813	case TCSBRK:
2814	case TCSBRKP:	2814	case TCSBRKP:
2815	retval = tty_check_change(tty);	2815	retval = tty_check_change(tty);
2816	if (retval)	2816	if (retval)
2817	return retval;	2817	return retval;
2818	if (cmd != TIOCCBRK) {	2818	if (cmd != TIOCCBRK) {
2819	tty_wait_until_sent(tty, 0);	2819	tty_wait_until_sent(tty, 0);
2820	if (signal_pending(current))	2820	if (signal_pending(current))
2821	return -EINTR;	2821	return -EINTR;
2822	}	2822	}
2823	break;	2823	break;
2824	}	2824	}
2825		2825
2826	/*	2826	/*
2827	* Now do the stuff.	2827	* Now do the stuff.
2828	*/	2828	*/
2829	switch (cmd) {	2829	switch (cmd) {
2830	case TIOCSTI:	2830	case TIOCSTI:
2831	return tiocsti(tty, p);	2831	return tiocsti(tty, p);
2832	case TIOCGWINSZ:	2832	case TIOCGWINSZ:
2833	return tiocgwinsz(real_tty, p);	2833	return tiocgwinsz(real_tty, p);
2834	case TIOCSWINSZ:	2834	case TIOCSWINSZ:
2835	return tiocswinsz(real_tty, p);	2835	return tiocswinsz(real_tty, p);
2836	case TIOCCONS:	2836	case TIOCCONS:
2837	return real_tty != tty ? -EINVAL : tioccons(file);	2837	return real_tty != tty ? -EINVAL : tioccons(file);
2838	case FIONBIO:	2838	case FIONBIO:
2839	return fionbio(file, p);	2839	return fionbio(file, p);
2840	case TIOCEXCL:	2840	case TIOCEXCL:
2841	set_bit(TTY_EXCLUSIVE, &tty->flags);	2841	set_bit(TTY_EXCLUSIVE, &tty->flags);
2842	return 0;	2842	return 0;
2843	case TIOCNXCL:	2843	case TIOCNXCL:
2844	clear_bit(TTY_EXCLUSIVE, &tty->flags);	2844	clear_bit(TTY_EXCLUSIVE, &tty->flags);
2845	return 0;	2845	return 0;
2846	case TIOCGEXCL:	2846	case TIOCGEXCL:
2847	{	2847	{
2848	int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);	2848	int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
2849	return put_user(excl, (int __user *)p);	2849	return put_user(excl, (int __user *)p);
2850	}	2850	}
2851	case TIOCNOTTY:	2851	case TIOCNOTTY:
2852	if (current->signal->tty != tty)	2852	if (current->signal->tty != tty)
2853	return -ENOTTY;	2853	return -ENOTTY;
2854	no_tty();	2854	no_tty();
2855	return 0;	2855	return 0;
2856	case TIOCSCTTY:	2856	case TIOCSCTTY:
2857	return tiocsctty(tty, arg);	2857	return tiocsctty(tty, arg);
2858	case TIOCGPGRP:	2858	case TIOCGPGRP:
2859	return tiocgpgrp(tty, real_tty, p);	2859	return tiocgpgrp(tty, real_tty, p);
2860	case TIOCSPGRP:	2860	case TIOCSPGRP:
2861	return tiocspgrp(tty, real_tty, p);	2861	return tiocspgrp(tty, real_tty, p);
2862	case TIOCGSID:	2862	case TIOCGSID:
2863	return tiocgsid(tty, real_tty, p);	2863	return tiocgsid(tty, real_tty, p);
2864	case TIOCGETD:	2864	case TIOCGETD:
2865	return put_user(tty->ldisc->ops->num, (int __user *)p);	2865	return put_user(tty->ldisc->ops->num, (int __user *)p);
2866	case TIOCSETD:	2866	case TIOCSETD:
2867	return tiocsetd(tty, p);	2867	return tiocsetd(tty, p);
2868	case TIOCVHANGUP:	2868	case TIOCVHANGUP:
2869	if (!capable(CAP_SYS_ADMIN))	2869	if (!capable(CAP_SYS_ADMIN))
2870	return -EPERM;	2870	return -EPERM;
2871	tty_vhangup(tty);	2871	tty_vhangup(tty);
2872	return 0;	2872	return 0;
2873	case TIOCGDEV:	2873	case TIOCGDEV:
2874	{	2874	{
2875	unsigned int ret = new_encode_dev(tty_devnum(real_tty));	2875	unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2876	return put_user(ret, (unsigned int __user *)p);	2876	return put_user(ret, (unsigned int __user *)p);
2877	}	2877	}
2878	/*	2878	/*
2879	* Break handling	2879	* Break handling
2880	*/	2880	*/
2881	case TIOCSBRK: /* Turn break on, unconditionally */	2881	case TIOCSBRK: /* Turn break on, unconditionally */
2882	if (tty->ops->break_ctl)	2882	if (tty->ops->break_ctl)
2883	return tty->ops->break_ctl(tty, -1);	2883	return tty->ops->break_ctl(tty, -1);
2884	return 0;	2884	return 0;
2885	case TIOCCBRK: /* Turn break off, unconditionally */	2885	case TIOCCBRK: /* Turn break off, unconditionally */
2886	if (tty->ops->break_ctl)	2886	if (tty->ops->break_ctl)
2887	return tty->ops->break_ctl(tty, 0);	2887	return tty->ops->break_ctl(tty, 0);
2888	return 0;	2888	return 0;
2889	case TCSBRK: /* SVID version: non-zero arg --> no break */	2889	case TCSBRK: /* SVID version: non-zero arg --> no break */
2890	/* non-zero arg means wait for all output data	2890	/* non-zero arg means wait for all output data
2891	* to be sent (performed above) but don't send break.	2891	* to be sent (performed above) but don't send break.
2892	* This is used by the tcdrain() termios function.	2892	* This is used by the tcdrain() termios function.
2893	*/	2893	*/
2894	if (!arg)	2894	if (!arg)
2895	return send_break(tty, 250);	2895	return send_break(tty, 250);
2896	return 0;	2896	return 0;
2897	case TCSBRKP: /* support for POSIX tcsendbreak() */	2897	case TCSBRKP: /* support for POSIX tcsendbreak() */
2898	return send_break(tty, arg ? arg*100 : 250);	2898	return send_break(tty, arg ? arg*100 : 250);
2899		2899
2900	case TIOCMGET:	2900	case TIOCMGET:
2901	return tty_tiocmget(tty, p);	2901	return tty_tiocmget(tty, p);
2902	case TIOCMSET:	2902	case TIOCMSET:
2903	case TIOCMBIC:	2903	case TIOCMBIC:
2904	case TIOCMBIS:	2904	case TIOCMBIS:
2905	return tty_tiocmset(tty, cmd, p);	2905	return tty_tiocmset(tty, cmd, p);
2906	case TIOCGICOUNT:	2906	case TIOCGICOUNT:
2907	retval = tty_tiocgicount(tty, p);	2907	retval = tty_tiocgicount(tty, p);
2908	/* For the moment allow fall through to the old method */	2908	/* For the moment allow fall through to the old method */
2909	if (retval != -EINVAL)	2909	if (retval != -EINVAL)
2910	return retval;	2910	return retval;
2911	break;	2911	break;
2912	case TCFLSH:	2912	case TCFLSH:
2913	switch (arg) {	2913	switch (arg) {
2914	case TCIFLUSH:	2914	case TCIFLUSH:
2915	case TCIOFLUSH:	2915	case TCIOFLUSH:
2916	/* flush tty buffer and allow ldisc to process ioctl */	2916	/* flush tty buffer and allow ldisc to process ioctl */
2917	tty_buffer_flush(tty, NULL);	2917	tty_buffer_flush(tty, NULL);
2918	break;	2918	break;
2919	}	2919	}
2920	break;	2920	break;
2921	case TIOCSSERIAL:	2921	case TIOCSSERIAL:
2922	tty_warn_deprecated_flags(p);	2922	tty_warn_deprecated_flags(p);
2923	break;	2923	break;
2924	}	2924	}
2925	if (tty->ops->ioctl) {	2925	if (tty->ops->ioctl) {
2926	retval = tty->ops->ioctl(tty, cmd, arg);	2926	retval = tty->ops->ioctl(tty, cmd, arg);
2927	if (retval != -ENOIOCTLCMD)	2927	if (retval != -ENOIOCTLCMD)
2928	return retval;	2928	return retval;
2929	}	2929	}
2930	ld = tty_ldisc_ref_wait(tty);	2930	ld = tty_ldisc_ref_wait(tty);
2931	retval = -EINVAL;	2931	retval = -EINVAL;
2932	if (ld->ops->ioctl) {	2932	if (ld->ops->ioctl) {
2933	retval = ld->ops->ioctl(tty, file, cmd, arg);	2933	retval = ld->ops->ioctl(tty, file, cmd, arg);
2934	if (retval == -ENOIOCTLCMD)	2934	if (retval == -ENOIOCTLCMD)
2935	retval = -ENOTTY;	2935	retval = -ENOTTY;
2936	}	2936	}
2937	tty_ldisc_deref(ld);	2937	tty_ldisc_deref(ld);
2938	return retval;	2938	return retval;
2939	}	2939	}
2940		2940
2941	#ifdef CONFIG_COMPAT	2941	#ifdef CONFIG_COMPAT
2942	static long tty_compat_ioctl(struct file *file, unsigned int cmd,	2942	static long tty_compat_ioctl(struct file *file, unsigned int cmd,
2943	unsigned long arg)	2943	unsigned long arg)
2944	{	2944	{
2945	struct tty_struct *tty = file_tty(file);	2945	struct tty_struct *tty = file_tty(file);
2946	struct tty_ldisc *ld;	2946	struct tty_ldisc *ld;
2947	int retval = -ENOIOCTLCMD;	2947	int retval = -ENOIOCTLCMD;
2948		2948
2949	if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))	2949	if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
2950	return -EINVAL;	2950	return -EINVAL;
2951		2951
2952	if (tty->ops->compat_ioctl) {	2952	if (tty->ops->compat_ioctl) {
2953	retval = tty->ops->compat_ioctl(tty, cmd, arg);	2953	retval = tty->ops->compat_ioctl(tty, cmd, arg);
2954	if (retval != -ENOIOCTLCMD)	2954	if (retval != -ENOIOCTLCMD)
2955	return retval;	2955	return retval;
2956	}	2956	}
2957		2957
2958	ld = tty_ldisc_ref_wait(tty);	2958	ld = tty_ldisc_ref_wait(tty);
2959	if (ld->ops->compat_ioctl)	2959	if (ld->ops->compat_ioctl)
2960	retval = ld->ops->compat_ioctl(tty, file, cmd, arg);	2960	retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
2961	else	2961	else
2962	retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);	2962	retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
2963	tty_ldisc_deref(ld);	2963	tty_ldisc_deref(ld);
2964		2964
2965	return retval;	2965	return retval;
2966	}	2966	}
2967	#endif	2967	#endif
2968		2968
2969	static int this_tty(const void t, struct file file, unsigned fd)	2969	static int this_tty(const void t, struct file file, unsigned fd)
2970	{	2970	{
2971	if (likely(file->f_op->read != tty_read))	2971	if (likely(file->f_op->read != tty_read))
2972	return 0;	2972	return 0;
2973	return file_tty(file) != t ? 0 : fd + 1;	2973	return file_tty(file) != t ? 0 : fd + 1;
2974	}	2974	}
2975		2975
2976	/*	2976	/*
2977	* This implements the "Secure Attention Key" --- the idea is to	2977	* This implements the "Secure Attention Key" --- the idea is to
2978	* prevent trojan horses by killing all processes associated with this	2978	* prevent trojan horses by killing all processes associated with this
2979	* tty when the user hits the "Secure Attention Key". Required for	2979	* tty when the user hits the "Secure Attention Key". Required for
2980	* super-paranoid applications --- see the Orange Book for more details.	2980	* super-paranoid applications --- see the Orange Book for more details.
2981	*	2981	*
2982	* This code could be nicer; ideally it should send a HUP, wait a few	2982	* This code could be nicer; ideally it should send a HUP, wait a few
2983	* seconds, then send a INT, and then a KILL signal. But you then	2983	* seconds, then send a INT, and then a KILL signal. But you then
2984	* have to coordinate with the init process, since all processes associated	2984	* have to coordinate with the init process, since all processes associated
2985	* with the current tty must be dead before the new getty is allowed	2985	* with the current tty must be dead before the new getty is allowed
2986	* to spawn.	2986	* to spawn.
2987	*	2987	*
2988	* Now, if it would be correct ;-/ The current code has a nasty hole -	2988	* Now, if it would be correct ;-/ The current code has a nasty hole -
2989	* it doesn't catch files in flight. We may send the descriptor to ourselves	2989	* it doesn't catch files in flight. We may send the descriptor to ourselves
2990	* via AF_UNIX socket, close it and later fetch from socket. FIXME.	2990	* via AF_UNIX socket, close it and later fetch from socket. FIXME.
2991	*	2991	*
2992	* Nasty bug: do_SAK is being called in interrupt context. This can	2992	* Nasty bug: do_SAK is being called in interrupt context. This can
2993	* deadlock. We punt it up to process context. AKPM - 16Mar2001	2993	* deadlock. We punt it up to process context. AKPM - 16Mar2001
2994	*/	2994	*/
2995	void __do_SAK(struct tty_struct *tty)	2995	void __do_SAK(struct tty_struct *tty)
2996	{	2996	{
2997	#ifdef TTY_SOFT_SAK	2997	#ifdef TTY_SOFT_SAK
2998	tty_hangup(tty);	2998	tty_hangup(tty);
2999	#else	2999	#else
3000	struct task_struct g, p;	3000	struct task_struct g, p;
3001	struct pid *session;	3001	struct pid *session;
3002	int i;	3002	int i;
3003		3003
3004	if (!tty)	3004	if (!tty)
3005	return;	3005	return;
3006	session = tty->session;	3006	session = tty->session;
3007		3007
3008	tty_ldisc_flush(tty);	3008	tty_ldisc_flush(tty);
3009		3009
3010	tty_driver_flush_buffer(tty);	3010	tty_driver_flush_buffer(tty);
3011		3011
3012	read_lock(&tasklist_lock);	3012	read_lock(&tasklist_lock);
3013	/* Kill the entire session */	3013	/* Kill the entire session */
3014	do_each_pid_task(session, PIDTYPE_SID, p) {	3014	do_each_pid_task(session, PIDTYPE_SID, p) {
3015	printk(KERN_NOTICE "SAK: killed process %d"	3015	printk(KERN_NOTICE "SAK: killed process %d"
3016	" (%s): task_session(p)==tty->session\n",	3016	" (%s): task_session(p)==tty->session\n",
3017	task_pid_nr(p), p->comm);	3017	task_pid_nr(p), p->comm);
3018	send_sig(SIGKILL, p, 1);	3018	send_sig(SIGKILL, p, 1);
3019	} while_each_pid_task(session, PIDTYPE_SID, p);	3019	} while_each_pid_task(session, PIDTYPE_SID, p);
3020	/* Now kill any processes that happen to have the	3020	/* Now kill any processes that happen to have the
3021	* tty open.	3021	* tty open.
3022	*/	3022	*/
3023	do_each_thread(g, p) {	3023	do_each_thread(g, p) {
3024	if (p->signal->tty == tty) {	3024	if (p->signal->tty == tty) {
3025	printk(KERN_NOTICE "SAK: killed process %d"	3025	printk(KERN_NOTICE "SAK: killed process %d"
3026	" (%s): task_session(p)==tty->session\n",	3026	" (%s): task_session(p)==tty->session\n",
3027	task_pid_nr(p), p->comm);	3027	task_pid_nr(p), p->comm);
3028	send_sig(SIGKILL, p, 1);	3028	send_sig(SIGKILL, p, 1);
3029	continue;	3029	continue;
3030	}	3030	}
3031	task_lock(p);	3031	task_lock(p);
3032	i = iterate_fd(p->files, 0, this_tty, tty);	3032	i = iterate_fd(p->files, 0, this_tty, tty);
3033	if (i != 0) {	3033	if (i != 0) {
3034	printk(KERN_NOTICE "SAK: killed process %d"	3034	printk(KERN_NOTICE "SAK: killed process %d"
3035	" (%s): fd#%d opened to the tty\n",	3035	" (%s): fd#%d opened to the tty\n",
3036	task_pid_nr(p), p->comm, i - 1);	3036	task_pid_nr(p), p->comm, i - 1);
3037	force_sig(SIGKILL, p);	3037	force_sig(SIGKILL, p);
3038	}	3038	}
3039	task_unlock(p);	3039	task_unlock(p);
3040	} while_each_thread(g, p);	3040	} while_each_thread(g, p);
3041	read_unlock(&tasklist_lock);	3041	read_unlock(&tasklist_lock);
3042	#endif	3042	#endif
3043	}	3043	}
3044		3044
3045	static void do_SAK_work(struct work_struct *work)	3045	static void do_SAK_work(struct work_struct *work)
3046	{	3046	{
3047	struct tty_struct *tty =	3047	struct tty_struct *tty =
3048	container_of(work, struct tty_struct, SAK_work);	3048	container_of(work, struct tty_struct, SAK_work);
3049	__do_SAK(tty);	3049	__do_SAK(tty);
3050	}	3050	}
3051		3051
3052	/*	3052	/*
3053	* The tq handling here is a little racy - tty->SAK_work may already be queued.	3053	* The tq handling here is a little racy - tty->SAK_work may already be queued.
3054	* Fortunately we don't need to worry, because if ->SAK_work is already queued,	3054	* Fortunately we don't need to worry, because if ->SAK_work is already queued,
3055	* the values which we write to it will be identical to the values which it	3055	* the values which we write to it will be identical to the values which it
3056	* already has. --akpm	3056	* already has. --akpm
3057	*/	3057	*/
3058	void do_SAK(struct tty_struct *tty)	3058	void do_SAK(struct tty_struct *tty)
3059	{	3059	{
3060	if (!tty)	3060	if (!tty)
3061	return;	3061	return;
3062	schedule_work(&tty->SAK_work);	3062	schedule_work(&tty->SAK_work);
3063	}	3063	}
3064		3064
3065	EXPORT_SYMBOL(do_SAK);	3065	EXPORT_SYMBOL(do_SAK);
3066		3066
3067	static int dev_match_devt(struct device dev, const void data)	3067	static int dev_match_devt(struct device dev, const void data)
3068	{	3068	{
3069	const dev_t *devt = data;	3069	const dev_t *devt = data;
3070	return dev->devt == *devt;	3070	return dev->devt == *devt;
3071	}	3071	}
3072		3072
3073	/* Must put_device() after it's unused! */	3073	/* Must put_device() after it's unused! */
3074	static struct device tty_get_device(struct tty_struct tty)	3074	static struct device tty_get_device(struct tty_struct tty)
3075	{	3075	{
3076	dev_t devt = tty_devnum(tty);	3076	dev_t devt = tty_devnum(tty);
3077	return class_find_device(tty_class, NULL, &devt, dev_match_devt);	3077	return class_find_device(tty_class, NULL, &devt, dev_match_devt);
3078	}	3078	}
3079		3079
3080		3080
3081	/**	3081	/**
3082	* alloc_tty_struct	3082	* alloc_tty_struct
3083	*	3083	*
3084	* This subroutine allocates and initializes a tty structure.	3084	* This subroutine allocates and initializes a tty structure.
3085	*	3085	*
3086	* Locking: none - tty in question is not exposed at this point	3086	* Locking: none - tty in question is not exposed at this point
3087	*/	3087	*/
3088		3088
3089	struct tty_struct alloc_tty_struct(struct tty_driver driver, int idx)	3089	struct tty_struct alloc_tty_struct(struct tty_driver driver, int idx)
3090	{	3090	{
3091	struct tty_struct *tty;	3091	struct tty_struct *tty;
3092		3092
3093	tty = kzalloc(sizeof(*tty), GFP_KERNEL);	3093	tty = kzalloc(sizeof(*tty), GFP_KERNEL);
3094	if (!tty)	3094	if (!tty)
3095	return NULL;	3095	return NULL;
3096		3096
3097	kref_init(&tty->kref);	3097	kref_init(&tty->kref);
3098	tty->magic = TTY_MAGIC;	3098	tty->magic = TTY_MAGIC;
3099	tty_ldisc_init(tty);	3099	tty_ldisc_init(tty);
3100	tty->session = NULL;	3100	tty->session = NULL;
3101	tty->pgrp = NULL;	3101	tty->pgrp = NULL;
3102	mutex_init(&tty->legacy_mutex);	3102	mutex_init(&tty->legacy_mutex);
3103	mutex_init(&tty->throttle_mutex);	3103	mutex_init(&tty->throttle_mutex);
3104	init_rwsem(&tty->termios_rwsem);	3104	init_rwsem(&tty->termios_rwsem);
3105	mutex_init(&tty->winsize_mutex);	3105	mutex_init(&tty->winsize_mutex);
3106	init_ldsem(&tty->ldisc_sem);	3106	init_ldsem(&tty->ldisc_sem);
3107	init_waitqueue_head(&tty->write_wait);	3107	init_waitqueue_head(&tty->write_wait);
3108	init_waitqueue_head(&tty->read_wait);	3108	init_waitqueue_head(&tty->read_wait);
3109	INIT_WORK(&tty->hangup_work, do_tty_hangup);	3109	INIT_WORK(&tty->hangup_work, do_tty_hangup);
3110	mutex_init(&tty->atomic_write_lock);	3110	mutex_init(&tty->atomic_write_lock);
3111	spin_lock_init(&tty->ctrl_lock);	3111	spin_lock_init(&tty->ctrl_lock);
3112	spin_lock_init(&tty->flow_lock);	3112	spin_lock_init(&tty->flow_lock);
3113	INIT_LIST_HEAD(&tty->tty_files);	3113	INIT_LIST_HEAD(&tty->tty_files);
3114	INIT_WORK(&tty->SAK_work, do_SAK_work);	3114	INIT_WORK(&tty->SAK_work, do_SAK_work);
3115		3115
3116	tty->driver = driver;	3116	tty->driver = driver;
3117	tty->ops = driver->ops;	3117	tty->ops = driver->ops;
3118	tty->index = idx;	3118	tty->index = idx;
3119	tty_line_name(driver, idx, tty->name);	3119	tty_line_name(driver, idx, tty->name);
3120	tty->dev = tty_get_device(tty);	3120	tty->dev = tty_get_device(tty);
3121		3121
3122	return tty;	3122	return tty;
3123	}	3123	}
3124		3124
3125	/**	3125	/**
3126	* deinitialize_tty_struct	3126	* deinitialize_tty_struct
3127	* @tty: tty to deinitialize	3127	* @tty: tty to deinitialize
3128	*	3128	*
3129	* This subroutine deinitializes a tty structure that has been newly	3129	* This subroutine deinitializes a tty structure that has been newly
3130	* allocated but tty_release cannot be called on that yet.	3130	* allocated but tty_release cannot be called on that yet.
3131	*	3131	*
3132	* Locking: none - tty in question must not be exposed at this point	3132	* Locking: none - tty in question must not be exposed at this point
3133	*/	3133	*/
3134	void deinitialize_tty_struct(struct tty_struct *tty)	3134	void deinitialize_tty_struct(struct tty_struct *tty)
3135	{	3135	{
3136	tty_ldisc_deinit(tty);	3136	tty_ldisc_deinit(tty);
3137	}	3137	}
3138		3138
3139	/**	3139	/**
3140	* tty_put_char - write one character to a tty	3140	* tty_put_char - write one character to a tty
3141	* @tty: tty	3141	* @tty: tty
3142	* @ch: character	3142	* @ch: character
3143	*	3143	*
3144	* Write one byte to the tty using the provided put_char method	3144	* Write one byte to the tty using the provided put_char method
3145	* if present. Returns the number of characters successfully output.	3145	* if present. Returns the number of characters successfully output.
3146	*	3146	*
3147	* Note: the specific put_char operation in the driver layer may go	3147	* Note: the specific put_char operation in the driver layer may go
3148	* away soon. Don't call it directly, use this method	3148	* away soon. Don't call it directly, use this method
3149	*/	3149	*/
3150		3150
3151	int tty_put_char(struct tty_struct *tty, unsigned char ch)	3151	int tty_put_char(struct tty_struct *tty, unsigned char ch)
3152	{	3152	{
3153	if (tty->ops->put_char)	3153	if (tty->ops->put_char)
3154	return tty->ops->put_char(tty, ch);	3154	return tty->ops->put_char(tty, ch);
3155	return tty->ops->write(tty, &ch, 1);	3155	return tty->ops->write(tty, &ch, 1);
3156	}	3156	}
3157	EXPORT_SYMBOL_GPL(tty_put_char);	3157	EXPORT_SYMBOL_GPL(tty_put_char);
3158		3158
3159	struct class *tty_class;	3159	struct class *tty_class;
3160		3160
3161	static int tty_cdev_add(struct tty_driver *driver, dev_t dev,	3161	static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
3162	unsigned int index, unsigned int count)	3162	unsigned int index, unsigned int count)
3163	{	3163	{
3164	/* init here, since reused cdevs cause crashes */	3164	/* init here, since reused cdevs cause crashes */
3165	cdev_init(&driver->cdevs[index], &tty_fops);	3165	cdev_init(&driver->cdevs[index], &tty_fops);
3166	driver->cdevs[index].owner = driver->owner;	3166	driver->cdevs[index].owner = driver->owner;
3167	return cdev_add(&driver->cdevs[index], dev, count);	3167	return cdev_add(&driver->cdevs[index], dev, count);
3168	}	3168	}
3169		3169
3170	/**	3170	/**
3171	* tty_register_device - register a tty device	3171	* tty_register_device - register a tty device
3172	* @driver: the tty driver that describes the tty device	3172	* @driver: the tty driver that describes the tty device
3173	* @index: the index in the tty driver for this tty device	3173	* @index: the index in the tty driver for this tty device
3174	* @device: a struct device that is associated with this tty device.	3174	* @device: a struct device that is associated with this tty device.
3175	* This field is optional, if there is no known struct device	3175	* This field is optional, if there is no known struct device
3176	* for this tty device it can be set to NULL safely.	3176	* for this tty device it can be set to NULL safely.
3177	*	3177	*
3178	* Returns a pointer to the struct device for this tty device	3178	* Returns a pointer to the struct device for this tty device
3179	* (or ERR_PTR(-EFOO) on error).	3179	* (or ERR_PTR(-EFOO) on error).
3180	*	3180	*
3181	* This call is required to be made to register an individual tty device	3181	* This call is required to be made to register an individual tty device
3182	* if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If	3182	* if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3183	* that bit is not set, this function should not be called by a tty	3183	* that bit is not set, this function should not be called by a tty
3184	* driver.	3184	* driver.
3185	*	3185	*
3186	* Locking: ??	3186	* Locking: ??
3187	*/	3187	*/
3188		3188
3189	struct device tty_register_device(struct tty_driver driver, unsigned index,	3189	struct device tty_register_device(struct tty_driver driver, unsigned index,
3190	struct device *device)	3190	struct device *device)
3191	{	3191	{
3192	return tty_register_device_attr(driver, index, device, NULL, NULL);	3192	return tty_register_device_attr(driver, index, device, NULL, NULL);
3193	}	3193	}
3194	EXPORT_SYMBOL(tty_register_device);	3194	EXPORT_SYMBOL(tty_register_device);
3195		3195
3196	static void tty_device_create_release(struct device *dev)	3196	static void tty_device_create_release(struct device *dev)
3197	{	3197	{
3198	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);	3198	pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
3199	kfree(dev);	3199	kfree(dev);
3200	}	3200	}
3201		3201
3202	/**	3202	/**
3203	* tty_register_device_attr - register a tty device	3203	* tty_register_device_attr - register a tty device
3204	* @driver: the tty driver that describes the tty device	3204	* @driver: the tty driver that describes the tty device
3205	* @index: the index in the tty driver for this tty device	3205	* @index: the index in the tty driver for this tty device
3206	* @device: a struct device that is associated with this tty device.	3206	* @device: a struct device that is associated with this tty device.
3207	* This field is optional, if there is no known struct device	3207	* This field is optional, if there is no known struct device
3208	* for this tty device it can be set to NULL safely.	3208	* for this tty device it can be set to NULL safely.
3209	* @drvdata: Driver data to be set to device.	3209	* @drvdata: Driver data to be set to device.
3210	* @attr_grp: Attribute group to be set on device.	3210	* @attr_grp: Attribute group to be set on device.
3211	*	3211	*
3212	* Returns a pointer to the struct device for this tty device	3212	* Returns a pointer to the struct device for this tty device
3213	* (or ERR_PTR(-EFOO) on error).	3213	* (or ERR_PTR(-EFOO) on error).
3214	*	3214	*
3215	* This call is required to be made to register an individual tty device	3215	* This call is required to be made to register an individual tty device
3216	* if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If	3216	* if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set. If
3217	* that bit is not set, this function should not be called by a tty	3217	* that bit is not set, this function should not be called by a tty
3218	* driver.	3218	* driver.
3219	*	3219	*
3220	* Locking: ??	3220	* Locking: ??
3221	*/	3221	*/
3222	struct device tty_register_device_attr(struct tty_driver driver,	3222	struct device tty_register_device_attr(struct tty_driver driver,
3223	unsigned index, struct device *device,	3223	unsigned index, struct device *device,
3224	void *drvdata,	3224	void *drvdata,
3225	const struct attribute_group **attr_grp)	3225	const struct attribute_group **attr_grp)
3226	{	3226	{
3227	char name[64];	3227	char name[64];
3228	dev_t devt = MKDEV(driver->major, driver->minor_start) + index;	3228	dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
3229	struct device *dev = NULL;	3229	struct device *dev = NULL;
3230	int retval = -ENODEV;	3230	int retval = -ENODEV;
3231	bool cdev = false;	3231	bool cdev = false;
3232		3232
3233	if (index >= driver->num) {	3233	if (index >= driver->num) {
3234	printk(KERN_ERR "Attempt to register invalid tty line number "	3234	printk(KERN_ERR "Attempt to register invalid tty line number "
3235	" (%d).\n", index);	3235	" (%d).\n", index);
3236	return ERR_PTR(-EINVAL);	3236	return ERR_PTR(-EINVAL);
3237	}	3237	}
3238		3238
3239	if (driver->type == TTY_DRIVER_TYPE_PTY)	3239	if (driver->type == TTY_DRIVER_TYPE_PTY)
3240	pty_line_name(driver, index, name);	3240	pty_line_name(driver, index, name);
3241	else	3241	else
3242	tty_line_name(driver, index, name);	3242	tty_line_name(driver, index, name);
3243		3243
3244	if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {	3244	if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3245	retval = tty_cdev_add(driver, devt, index, 1);	3245	retval = tty_cdev_add(driver, devt, index, 1);
3246	if (retval)	3246	if (retval)
3247	goto error;	3247	goto error;
3248	cdev = true;	3248	cdev = true;
3249	}	3249	}
3250		3250
3251	dev = kzalloc(sizeof(*dev), GFP_KERNEL);	3251	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3252	if (!dev) {	3252	if (!dev) {
3253	retval = -ENOMEM;	3253	retval = -ENOMEM;
3254	goto error;	3254	goto error;
3255	}	3255	}
3256		3256
3257	dev->devt = devt;	3257	dev->devt = devt;
3258	dev->class = tty_class;	3258	dev->class = tty_class;
3259	dev->parent = device;	3259	dev->parent = device;
3260	dev->release = tty_device_create_release;	3260	dev->release = tty_device_create_release;
3261	dev_set_name(dev, "%s", name);	3261	dev_set_name(dev, "%s", name);
3262	dev->groups = attr_grp;	3262	dev->groups = attr_grp;
3263	dev_set_drvdata(dev, drvdata);	3263	dev_set_drvdata(dev, drvdata);
3264		3264
3265	retval = device_register(dev);	3265	retval = device_register(dev);
3266	if (retval)	3266	if (retval)
3267	goto error;	3267	goto error;
3268		3268
3269	return dev;	3269	return dev;
3270		3270
3271	error:	3271	error:
3272	put_device(dev);	3272	put_device(dev);
3273	if (cdev)	3273	if (cdev)
3274	cdev_del(&driver->cdevs[index]);	3274	cdev_del(&driver->cdevs[index]);
3275	return ERR_PTR(retval);	3275	return ERR_PTR(retval);
3276	}	3276	}
3277	EXPORT_SYMBOL_GPL(tty_register_device_attr);	3277	EXPORT_SYMBOL_GPL(tty_register_device_attr);
3278		3278
3279	/**	3279	/**
3280	* tty_unregister_device - unregister a tty device	3280	* tty_unregister_device - unregister a tty device
3281	* @driver: the tty driver that describes the tty device	3281	* @driver: the tty driver that describes the tty device
3282	* @index: the index in the tty driver for this tty device	3282	* @index: the index in the tty driver for this tty device
3283	*	3283	*
3284	* If a tty device is registered with a call to tty_register_device() then	3284	* If a tty device is registered with a call to tty_register_device() then
3285	* this function must be called when the tty device is gone.	3285	* this function must be called when the tty device is gone.
3286	*	3286	*
3287	* Locking: ??	3287	* Locking: ??
3288	*/	3288	*/
3289		3289
3290	void tty_unregister_device(struct tty_driver *driver, unsigned index)	3290	void tty_unregister_device(struct tty_driver *driver, unsigned index)
3291	{	3291	{
3292	device_destroy(tty_class,	3292	device_destroy(tty_class,
3293	MKDEV(driver->major, driver->minor_start) + index);	3293	MKDEV(driver->major, driver->minor_start) + index);
3294	if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC))	3294	if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC))
3295	cdev_del(&driver->cdevs[index]);	3295	cdev_del(&driver->cdevs[index]);
3296	}	3296	}
3297	EXPORT_SYMBOL(tty_unregister_device);	3297	EXPORT_SYMBOL(tty_unregister_device);
3298		3298
3299	/**	3299	/**
3300	* __tty_alloc_driver -- allocate tty driver	3300	* __tty_alloc_driver -- allocate tty driver
3301	* @lines: count of lines this driver can handle at most	3301	* @lines: count of lines this driver can handle at most
3302	* @owner: module which is repsonsible for this driver	3302	* @owner: module which is repsonsible for this driver
3303	* @flags: some of TTY_DRIVER_* flags, will be set in driver->flags	3303	* @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
3304	*	3304	*
3305	* This should not be called directly, some of the provided macros should be	3305	* This should not be called directly, some of the provided macros should be
3306	* used instead. Use IS_ERR and friends on @retval.	3306	* used instead. Use IS_ERR and friends on @retval.
3307	*/	3307	*/
3308	struct tty_driver __tty_alloc_driver(unsigned int lines, struct module owner,	3308	struct tty_driver __tty_alloc_driver(unsigned int lines, struct module owner,
3309	unsigned long flags)	3309	unsigned long flags)
3310	{	3310	{
3311	struct tty_driver *driver;	3311	struct tty_driver *driver;
3312	unsigned int cdevs = 1;	3312	unsigned int cdevs = 1;
3313	int err;	3313	int err;
3314		3314
3315	if (!lines \|\| (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))	3315	if (!lines \|\| (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
3316	return ERR_PTR(-EINVAL);	3316	return ERR_PTR(-EINVAL);
3317		3317
3318	driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);	3318	driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
3319	if (!driver)	3319	if (!driver)
3320	return ERR_PTR(-ENOMEM);	3320	return ERR_PTR(-ENOMEM);
3321		3321
3322	kref_init(&driver->kref);	3322	kref_init(&driver->kref);
3323	driver->magic = TTY_DRIVER_MAGIC;	3323	driver->magic = TTY_DRIVER_MAGIC;
3324	driver->num = lines;	3324	driver->num = lines;
3325	driver->owner = owner;	3325	driver->owner = owner;
3326	driver->flags = flags;	3326	driver->flags = flags;
3327		3327
3328	if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {	3328	if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3329	driver->ttys = kcalloc(lines, sizeof(*driver->ttys),	3329	driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3330	GFP_KERNEL);	3330	GFP_KERNEL);
3331	driver->termios = kcalloc(lines, sizeof(*driver->termios),	3331	driver->termios = kcalloc(lines, sizeof(*driver->termios),
3332	GFP_KERNEL);	3332	GFP_KERNEL);
3333	if (!driver->ttys \|\| !driver->termios) {	3333	if (!driver->ttys \|\| !driver->termios) {
3334	err = -ENOMEM;	3334	err = -ENOMEM;
3335	goto err_free_all;	3335	goto err_free_all;
3336	}	3336	}
3337	}	3337	}
3338		3338
3339	if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {	3339	if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3340	driver->ports = kcalloc(lines, sizeof(*driver->ports),	3340	driver->ports = kcalloc(lines, sizeof(*driver->ports),
3341	GFP_KERNEL);	3341	GFP_KERNEL);
3342	if (!driver->ports) {	3342	if (!driver->ports) {
3343	err = -ENOMEM;	3343	err = -ENOMEM;
3344	goto err_free_all;	3344	goto err_free_all;
3345	}	3345	}
3346	cdevs = lines;	3346	cdevs = lines;
3347	}	3347	}
3348		3348
3349	driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);	3349	driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3350	if (!driver->cdevs) {	3350	if (!driver->cdevs) {
3351	err = -ENOMEM;	3351	err = -ENOMEM;
3352	goto err_free_all;	3352	goto err_free_all;
3353	}	3353	}
3354		3354
3355	return driver;	3355	return driver;
3356	err_free_all:	3356	err_free_all:
3357	kfree(driver->ports);	3357	kfree(driver->ports);
3358	kfree(driver->ttys);	3358	kfree(driver->ttys);
3359	kfree(driver->termios);	3359	kfree(driver->termios);
3360	kfree(driver);	3360	kfree(driver);
3361	return ERR_PTR(err);	3361	return ERR_PTR(err);
3362	}	3362	}
3363	EXPORT_SYMBOL(__tty_alloc_driver);	3363	EXPORT_SYMBOL(__tty_alloc_driver);
3364		3364
3365	static void destruct_tty_driver(struct kref *kref)	3365	static void destruct_tty_driver(struct kref *kref)
3366	{	3366	{
3367	struct tty_driver *driver = container_of(kref, struct tty_driver, kref);	3367	struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3368	int i;	3368	int i;
3369	struct ktermios *tp;	3369	struct ktermios *tp;
3370		3370
3371	if (driver->flags & TTY_DRIVER_INSTALLED) {	3371	if (driver->flags & TTY_DRIVER_INSTALLED) {
3372	/*	3372	/*
3373	* Free the termios and termios_locked structures because	3373	* Free the termios and termios_locked structures because
3374	* we don't want to get memory leaks when modular tty	3374	* we don't want to get memory leaks when modular tty
3375	* drivers are removed from the kernel.	3375	* drivers are removed from the kernel.
3376	*/	3376	*/
3377	for (i = 0; i < driver->num; i++) {	3377	for (i = 0; i < driver->num; i++) {
3378	tp = driver->termios[i];	3378	tp = driver->termios[i];
3379	if (tp) {	3379	if (tp) {
3380	driver->termios[i] = NULL;	3380	driver->termios[i] = NULL;
3381	kfree(tp);	3381	kfree(tp);
3382	}	3382	}
3383	if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))	3383	if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3384	tty_unregister_device(driver, i);	3384	tty_unregister_device(driver, i);
3385	}	3385	}
3386	proc_tty_unregister_driver(driver);	3386	proc_tty_unregister_driver(driver);
3387	if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)	3387	if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
3388	cdev_del(&driver->cdevs[0]);	3388	cdev_del(&driver->cdevs[0]);
3389	}	3389	}
3390	kfree(driver->cdevs);	3390	kfree(driver->cdevs);
3391	kfree(driver->ports);	3391	kfree(driver->ports);
3392	kfree(driver->termios);	3392	kfree(driver->termios);
3393	kfree(driver->ttys);	3393	kfree(driver->ttys);
3394	kfree(driver);	3394	kfree(driver);
3395	}	3395	}
3396		3396
3397	void tty_driver_kref_put(struct tty_driver *driver)	3397	void tty_driver_kref_put(struct tty_driver *driver)
3398	{	3398	{
3399	kref_put(&driver->kref, destruct_tty_driver);	3399	kref_put(&driver->kref, destruct_tty_driver);
3400	}	3400	}
3401	EXPORT_SYMBOL(tty_driver_kref_put);	3401	EXPORT_SYMBOL(tty_driver_kref_put);
3402		3402
3403	void tty_set_operations(struct tty_driver *driver,	3403	void tty_set_operations(struct tty_driver *driver,
3404	const struct tty_operations *op)	3404	const struct tty_operations *op)
3405	{	3405	{
3406	driver->ops = op;	3406	driver->ops = op;
3407	};	3407	};
3408	EXPORT_SYMBOL(tty_set_operations);	3408	EXPORT_SYMBOL(tty_set_operations);
3409		3409
3410	void put_tty_driver(struct tty_driver *d)	3410	void put_tty_driver(struct tty_driver *d)
3411	{	3411	{
3412	tty_driver_kref_put(d);	3412	tty_driver_kref_put(d);
3413	}	3413	}
3414	EXPORT_SYMBOL(put_tty_driver);	3414	EXPORT_SYMBOL(put_tty_driver);
3415		3415
3416	/*	3416	/*
3417	* Called by a tty driver to register itself.	3417	* Called by a tty driver to register itself.
3418	*/	3418	*/
3419	int tty_register_driver(struct tty_driver *driver)	3419	int tty_register_driver(struct tty_driver *driver)
3420	{	3420	{
3421	int error;	3421	int error;
3422	int i;	3422	int i;
3423	dev_t dev;	3423	dev_t dev;
3424	struct device *d;	3424	struct device *d;
3425		3425
3426	if (!driver->major) {	3426	if (!driver->major) {
3427	error = alloc_chrdev_region(&dev, driver->minor_start,	3427	error = alloc_chrdev_region(&dev, driver->minor_start,
3428	driver->num, driver->name);	3428	driver->num, driver->name);
3429	if (!error) {	3429	if (!error) {
3430	driver->major = MAJOR(dev);	3430	driver->major = MAJOR(dev);
3431	driver->minor_start = MINOR(dev);	3431	driver->minor_start = MINOR(dev);
3432	}	3432	}
3433	} else {	3433	} else {
3434	dev = MKDEV(driver->major, driver->minor_start);	3434	dev = MKDEV(driver->major, driver->minor_start);
3435	error = register_chrdev_region(dev, driver->num, driver->name);	3435	error = register_chrdev_region(dev, driver->num, driver->name);
3436	}	3436	}
3437	if (error < 0)	3437	if (error < 0)
3438	goto err;	3438	goto err;
3439		3439
3440	if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {	3440	if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3441	error = tty_cdev_add(driver, dev, 0, driver->num);	3441	error = tty_cdev_add(driver, dev, 0, driver->num);
3442	if (error)	3442	if (error)
3443	goto err_unreg_char;	3443	goto err_unreg_char;
3444	}	3444	}
3445		3445
3446	mutex_lock(&tty_mutex);	3446	mutex_lock(&tty_mutex);
3447	list_add(&driver->tty_drivers, &tty_drivers);	3447	list_add(&driver->tty_drivers, &tty_drivers);
3448	mutex_unlock(&tty_mutex);	3448	mutex_unlock(&tty_mutex);
3449		3449
3450	if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {	3450	if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
3451	for (i = 0; i < driver->num; i++) {	3451	for (i = 0; i < driver->num; i++) {
3452	d = tty_register_device(driver, i, NULL);	3452	d = tty_register_device(driver, i, NULL);
3453	if (IS_ERR(d)) {	3453	if (IS_ERR(d)) {
3454	error = PTR_ERR(d);	3454	error = PTR_ERR(d);
3455	goto err_unreg_devs;	3455	goto err_unreg_devs;
3456	}	3456	}
3457	}	3457	}
3458	}	3458	}
3459	proc_tty_register_driver(driver);	3459	proc_tty_register_driver(driver);
3460	driver->flags \|= TTY_DRIVER_INSTALLED;	3460	driver->flags \|= TTY_DRIVER_INSTALLED;
3461	return 0;	3461	return 0;
3462		3462
3463	err_unreg_devs:	3463	err_unreg_devs:
3464	for (i--; i >= 0; i--)	3464	for (i--; i >= 0; i--)
3465	tty_unregister_device(driver, i);	3465	tty_unregister_device(driver, i);
3466		3466
3467	mutex_lock(&tty_mutex);	3467	mutex_lock(&tty_mutex);
3468	list_del(&driver->tty_drivers);	3468	list_del(&driver->tty_drivers);
3469	mutex_unlock(&tty_mutex);	3469	mutex_unlock(&tty_mutex);
3470		3470
3471	err_unreg_char:	3471	err_unreg_char:
3472	unregister_chrdev_region(dev, driver->num);	3472	unregister_chrdev_region(dev, driver->num);
3473	err:	3473	err:
3474	return error;	3474	return error;
3475	}	3475	}
3476	EXPORT_SYMBOL(tty_register_driver);	3476	EXPORT_SYMBOL(tty_register_driver);
3477		3477
3478	/*	3478	/*
3479	* Called by a tty driver to unregister itself.	3479	* Called by a tty driver to unregister itself.
3480	*/	3480	*/
3481	int tty_unregister_driver(struct tty_driver *driver)	3481	int tty_unregister_driver(struct tty_driver *driver)
3482	{	3482	{
3483	#if 0	3483	#if 0
3484	/* FIXME */	3484	/* FIXME */
3485	if (driver->refcount)	3485	if (driver->refcount)
3486	return -EBUSY;	3486	return -EBUSY;
3487	#endif	3487	#endif
3488	unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),	3488	unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3489	driver->num);	3489	driver->num);
3490	mutex_lock(&tty_mutex);	3490	mutex_lock(&tty_mutex);
3491	list_del(&driver->tty_drivers);	3491	list_del(&driver->tty_drivers);
3492	mutex_unlock(&tty_mutex);	3492	mutex_unlock(&tty_mutex);
3493	return 0;	3493	return 0;
3494	}	3494	}
3495		3495
3496	EXPORT_SYMBOL(tty_unregister_driver);	3496	EXPORT_SYMBOL(tty_unregister_driver);
3497		3497
3498	dev_t tty_devnum(struct tty_struct *tty)	3498	dev_t tty_devnum(struct tty_struct *tty)
3499	{	3499	{
3500	return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;	3500	return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3501	}	3501	}
3502	EXPORT_SYMBOL(tty_devnum);	3502	EXPORT_SYMBOL(tty_devnum);
3503		3503
3504	void tty_default_fops(struct file_operations *fops)	3504	void tty_default_fops(struct file_operations *fops)
3505	{	3505	{
3506	*fops = tty_fops;	3506	*fops = tty_fops;
3507	}	3507	}
3508		3508
3509	/*	3509	/*
3510	* Initialize the console device. This is called early, so	3510	* Initialize the console device. This is called early, so
3511	* we can't necessarily depend on lots of kernel help here.	3511	* we can't necessarily depend on lots of kernel help here.
3512	* Just do some early initializations, and do the complex setup	3512	* Just do some early initializations, and do the complex setup
3513	* later.	3513	* later.
3514	*/	3514	*/
3515	void __init console_init(void)	3515	void __init console_init(void)
3516	{	3516	{
3517	initcall_t *call;	3517	initcall_t *call;
3518		3518
3519	/* Setup the default TTY line discipline. */	3519	/* Setup the default TTY line discipline. */
3520	tty_ldisc_begin();	3520	tty_ldisc_begin();
3521		3521
3522	/*	3522	/*
3523	* set up the console device so that later boot sequences can	3523	* set up the console device so that later boot sequences can
3524	* inform about problems etc..	3524	* inform about problems etc..
3525	*/	3525	*/
3526	call = __con_initcall_start;	3526	call = __con_initcall_start;
3527	while (call < __con_initcall_end) {	3527	while (call < __con_initcall_end) {
3528	(*call)();	3528	(*call)();
3529	call++;	3529	call++;
3530	}	3530	}
3531	}	3531	}
3532		3532
3533	static char tty_devnode(struct device dev, umode_t *mode)	3533	static char tty_devnode(struct device dev, umode_t *mode)
3534	{	3534	{
3535	if (!mode)	3535	if (!mode)
3536	return NULL;	3536	return NULL;
3537	if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) \|\|	3537	if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) \|\|
3538	dev->devt == MKDEV(TTYAUX_MAJOR, 2))	3538	dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3539	*mode = 0666;	3539	*mode = 0666;
3540	return NULL;	3540	return NULL;
3541	}	3541	}
3542		3542
3543	static int __init tty_class_init(void)	3543	static int __init tty_class_init(void)
3544	{	3544	{
3545	tty_class = class_create(THIS_MODULE, "tty");	3545	tty_class = class_create(THIS_MODULE, "tty");
3546	if (IS_ERR(tty_class))	3546	if (IS_ERR(tty_class))
3547	return PTR_ERR(tty_class);	3547	return PTR_ERR(tty_class);
3548	tty_class->devnode = tty_devnode;	3548	tty_class->devnode = tty_devnode;
3549	return 0;	3549	return 0;
3550	}	3550	}
3551		3551
3552	postcore_initcall(tty_class_init);	3552	postcore_initcall(tty_class_init);
3553		3553
3554	/* 3/2004 jmc: why do these devices exist? */	3554	/* 3/2004 jmc: why do these devices exist? */
3555	static struct cdev tty_cdev, console_cdev;	3555	static struct cdev tty_cdev, console_cdev;
3556		3556
3557	static ssize_t show_cons_active(struct device *dev,	3557	static ssize_t show_cons_active(struct device *dev,
3558	struct device_attribute attr, char buf)	3558	struct device_attribute attr, char buf)
3559	{	3559	{
3560	struct console *cs[16];	3560	struct console *cs[16];
3561	int i = 0;	3561	int i = 0;
3562	struct console *c;	3562	struct console *c;
3563	ssize_t count = 0;	3563	ssize_t count = 0;
3564		3564
3565	console_lock();	3565	console_lock();
3566	for_each_console(c) {	3566	for_each_console(c) {
3567	if (!c->device)	3567	if (!c->device)
3568	continue;	3568	continue;
3569	if (!c->write)	3569	if (!c->write)
3570	continue;	3570	continue;
3571	if ((c->flags & CON_ENABLED) == 0)	3571	if ((c->flags & CON_ENABLED) == 0)
3572	continue;	3572	continue;
3573	cs[i++] = c;	3573	cs[i++] = c;
3574	if (i >= ARRAY_SIZE(cs))	3574	if (i >= ARRAY_SIZE(cs))
3575	break;	3575	break;
3576	}	3576	}
3577	while (i--) {	3577	while (i--) {
3578	int index = cs[i]->index;	3578	int index = cs[i]->index;
3579	struct tty_driver *drv = cs[i]->device(cs[i], &index);	3579	struct tty_driver *drv = cs[i]->device(cs[i], &index);
3580		3580
3581	/* don't resolve tty0 as some programs depend on it */	3581	/* don't resolve tty0 as some programs depend on it */
3582	if (drv && (cs[i]->index > 0 \|\| drv->major != TTY_MAJOR))	3582	if (drv && (cs[i]->index > 0 \|\| drv->major != TTY_MAJOR))
3583	count += tty_line_name(drv, index, buf + count);	3583	count += tty_line_name(drv, index, buf + count);
3584	else	3584	else
3585	count += sprintf(buf + count, "%s%d",	3585	count += sprintf(buf + count, "%s%d",
3586	cs[i]->name, cs[i]->index);	3586	cs[i]->name, cs[i]->index);
3587		3587
3588	count += sprintf(buf + count, "%c", i ? ' ':'\n');	3588	count += sprintf(buf + count, "%c", i ? ' ':'\n');
3589	}	3589	}
3590	console_unlock();	3590	console_unlock();
3591		3591
3592	return count;	3592	return count;
3593	}	3593	}
3594	static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);	3594	static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3595		3595
3596	static struct device *consdev;	3596	static struct device *consdev;
3597		3597
3598	void console_sysfs_notify(void)	3598	void console_sysfs_notify(void)
3599	{	3599	{
3600	if (consdev)	3600	if (consdev)
3601	sysfs_notify(&consdev->kobj, NULL, "active");	3601	sysfs_notify(&consdev->kobj, NULL, "active");
3602	}	3602	}
3603		3603
3604	/*	3604	/*
3605	* Ok, now we can initialize the rest of the tty devices and can count	3605	* Ok, now we can initialize the rest of the tty devices and can count
3606	* on memory allocations, interrupts etc..	3606	* on memory allocations, interrupts etc..
3607	*/	3607	*/
3608	int __init tty_init(void)	3608	int __init tty_init(void)
3609	{	3609	{
3610	cdev_init(&tty_cdev, &tty_fops);	3610	cdev_init(&tty_cdev, &tty_fops);
3611	if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) \|\|	3611	if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) \|\|
3612	register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)	3612	register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3613	panic("Couldn't register /dev/tty driver\n");	3613	panic("Couldn't register /dev/tty driver\n");
3614	device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");	3614	device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3615		3615
3616	cdev_init(&console_cdev, &console_fops);	3616	cdev_init(&console_cdev, &console_fops);
3617	if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) \|\|	3617	if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) \|\|
3618	register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)	3618	register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3619	panic("Couldn't register /dev/console driver\n");	3619	panic("Couldn't register /dev/console driver\n");
3620	consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,	3620	consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
3621	"console");	3621	"console");
3622	if (IS_ERR(consdev))	3622	if (IS_ERR(consdev))
3623	consdev = NULL;	3623	consdev = NULL;
3624	else	3624	else
3625	WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);	3625	WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
3626		3626
3627	#ifdef CONFIG_VT	3627	#ifdef CONFIG_VT
3628	vty_init(&console_fops);	3628	vty_init(&console_fops);
3629	#endif	3629	#endif
3630	return 0;	3630	return 0;
3631	}	3631	}
3632		3632
3633		3633

drivers/tty/tty_ioctl.c

Diff comments View file @ bbbce51

1	/*	1	/*
2	* Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds	2	* Copyright (C) 1991, 1992, 1993, 1994 Linus Torvalds
3	*	3	*
4	* Modified by Fred N. van Kempen, 01/29/93, to add line disciplines	4	* Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
5	* which can be dynamically activated and de-activated by the line	5	* which can be dynamically activated and de-activated by the line
6	* discipline handling modules (like SLIP).	6	* discipline handling modules (like SLIP).
7	*/	7	*/
8		8
9	#include <linux/types.h>	9	#include <linux/types.h>
10	#include <linux/termios.h>	10	#include <linux/termios.h>
11	#include <linux/errno.h>	11	#include <linux/errno.h>
12	#include <linux/sched.h>	12	#include <linux/sched.h>
13	#include <linux/kernel.h>	13	#include <linux/kernel.h>
14	#include <linux/major.h>	14	#include <linux/major.h>
15	#include <linux/tty.h>	15	#include <linux/tty.h>
16	#include <linux/fcntl.h>	16	#include <linux/fcntl.h>
17	#include <linux/string.h>	17	#include <linux/string.h>
18	#include <linux/mm.h>	18	#include <linux/mm.h>
19	#include <linux/module.h>	19	#include <linux/module.h>
20	#include <linux/bitops.h>	20	#include <linux/bitops.h>
21	#include <linux/mutex.h>	21	#include <linux/mutex.h>
22	#include <linux/compat.h>	22	#include <linux/compat.h>
23		23
24	#include <asm/io.h>	24	#include <asm/io.h>
25	#include <asm/uaccess.h>	25	#include <asm/uaccess.h>
26		26
27	#undef TTY_DEBUG_WAIT_UNTIL_SENT	27	#undef TTY_DEBUG_WAIT_UNTIL_SENT
28		28
29	#undef DEBUG	29	#undef DEBUG
30		30
31	/*	31	/*
32	* Internal flag options for termios setting behavior	32	* Internal flag options for termios setting behavior
33	*/	33	*/
34	#define TERMIOS_FLUSH 1	34	#define TERMIOS_FLUSH 1
35	#define TERMIOS_WAIT 2	35	#define TERMIOS_WAIT 2
36	#define TERMIOS_TERMIO 4	36	#define TERMIOS_TERMIO 4
37	#define TERMIOS_OLD 8	37	#define TERMIOS_OLD 8
38		38
39		39
40	/**	40	/**
41	* tty_chars_in_buffer - characters pending	41	* tty_chars_in_buffer - characters pending
42	* @tty: terminal	42	* @tty: terminal
43	*	43	*
44	* Return the number of bytes of data in the device private	44	* Return the number of bytes of data in the device private
45	* output queue. If no private method is supplied there is assumed	45	* output queue. If no private method is supplied there is assumed
46	* to be no queue on the device.	46	* to be no queue on the device.
47	*/	47	*/
48		48
49	int tty_chars_in_buffer(struct tty_struct *tty)	49	int tty_chars_in_buffer(struct tty_struct *tty)
50	{	50	{
51	if (tty->ops->chars_in_buffer)	51	if (tty->ops->chars_in_buffer)
52	return tty->ops->chars_in_buffer(tty);	52	return tty->ops->chars_in_buffer(tty);
53	else	53	else
54	return 0;	54	return 0;
55	}	55	}
56	EXPORT_SYMBOL(tty_chars_in_buffer);	56	EXPORT_SYMBOL(tty_chars_in_buffer);
57		57
58	/**	58	/**
59	* tty_write_room - write queue space	59	* tty_write_room - write queue space
60	* @tty: terminal	60	* @tty: terminal
61	*	61	*
62	* Return the number of bytes that can be queued to this device	62	* Return the number of bytes that can be queued to this device
63	* at the present time. The result should be treated as a guarantee	63	* at the present time. The result should be treated as a guarantee
64	* and the driver cannot offer a value it later shrinks by more than	64	* and the driver cannot offer a value it later shrinks by more than
65	* the number of bytes written. If no method is provided 2K is always	65	* the number of bytes written. If no method is provided 2K is always
66	* returned and data may be lost as there will be no flow control.	66	* returned and data may be lost as there will be no flow control.
67	*/	67	*/
68		68
69	int tty_write_room(struct tty_struct *tty)	69	int tty_write_room(struct tty_struct *tty)
70	{	70	{
71	if (tty->ops->write_room)	71	if (tty->ops->write_room)
72	return tty->ops->write_room(tty);	72	return tty->ops->write_room(tty);
73	return 2048;	73	return 2048;
74	}	74	}
75	EXPORT_SYMBOL(tty_write_room);	75	EXPORT_SYMBOL(tty_write_room);
76		76
77	/**	77	/**
78	* tty_driver_flush_buffer - discard internal buffer	78	* tty_driver_flush_buffer - discard internal buffer
79	* @tty: terminal	79	* @tty: terminal
80	*	80	*
81	* Discard the internal output buffer for this device. If no method	81	* Discard the internal output buffer for this device. If no method
82	* is provided then either the buffer cannot be hardware flushed or	82	* is provided then either the buffer cannot be hardware flushed or
83	* there is no buffer driver side.	83	* there is no buffer driver side.
84	*/	84	*/
85	void tty_driver_flush_buffer(struct tty_struct *tty)	85	void tty_driver_flush_buffer(struct tty_struct *tty)
86	{	86	{
87	if (tty->ops->flush_buffer)	87	if (tty->ops->flush_buffer)
88	tty->ops->flush_buffer(tty);	88	tty->ops->flush_buffer(tty);
89	}	89	}
90	EXPORT_SYMBOL(tty_driver_flush_buffer);	90	EXPORT_SYMBOL(tty_driver_flush_buffer);
91		91
92	/**	92	/**
93	* tty_throttle - flow control	93	* tty_throttle - flow control
94	* @tty: terminal	94	* @tty: terminal
95	*	95	*
96	* Indicate that a tty should stop transmitting data down the stack.	96	* Indicate that a tty should stop transmitting data down the stack.
97	* Takes the termios rwsem to protect against parallel throttle/unthrottle	97	* Takes the termios rwsem to protect against parallel throttle/unthrottle
98	* and also to ensure the driver can consistently reference its own	98	* and also to ensure the driver can consistently reference its own
99	* termios data at this point when implementing software flow control.	99	* termios data at this point when implementing software flow control.
100	*/	100	*/
101		101
102	void tty_throttle(struct tty_struct *tty)	102	void tty_throttle(struct tty_struct *tty)
103	{	103	{
104	down_write(&tty->termios_rwsem);	104	down_write(&tty->termios_rwsem);
105	/* check TTY_THROTTLED first so it indicates our state */	105	/* check TTY_THROTTLED first so it indicates our state */
106	if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&	106	if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
107	tty->ops->throttle)	107	tty->ops->throttle)
108	tty->ops->throttle(tty);	108	tty->ops->throttle(tty);
109	tty->flow_change = 0;	109	tty->flow_change = 0;
110	up_write(&tty->termios_rwsem);	110	up_write(&tty->termios_rwsem);
111	}	111	}
112	EXPORT_SYMBOL(tty_throttle);	112	EXPORT_SYMBOL(tty_throttle);
113		113
114	/**	114	/**
115	* tty_unthrottle - flow control	115	* tty_unthrottle - flow control
116	* @tty: terminal	116	* @tty: terminal
117	*	117	*
118	* Indicate that a tty may continue transmitting data down the stack.	118	* Indicate that a tty may continue transmitting data down the stack.
119	* Takes the termios rwsem to protect against parallel throttle/unthrottle	119	* Takes the termios rwsem to protect against parallel throttle/unthrottle
120	* and also to ensure the driver can consistently reference its own	120	* and also to ensure the driver can consistently reference its own
121	* termios data at this point when implementing software flow control.	121	* termios data at this point when implementing software flow control.
122	*	122	*
123	* Drivers should however remember that the stack can issue a throttle,	123	* Drivers should however remember that the stack can issue a throttle,
124	* then change flow control method, then unthrottle.	124	* then change flow control method, then unthrottle.
125	*/	125	*/
126		126
127	void tty_unthrottle(struct tty_struct *tty)	127	void tty_unthrottle(struct tty_struct *tty)
128	{	128	{
129	down_write(&tty->termios_rwsem);	129	down_write(&tty->termios_rwsem);
130	if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&	130	if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
131	tty->ops->unthrottle)	131	tty->ops->unthrottle)
132	tty->ops->unthrottle(tty);	132	tty->ops->unthrottle(tty);
133	tty->flow_change = 0;	133	tty->flow_change = 0;
134	up_write(&tty->termios_rwsem);	134	up_write(&tty->termios_rwsem);
135	}	135	}
136	EXPORT_SYMBOL(tty_unthrottle);	136	EXPORT_SYMBOL(tty_unthrottle);
137		137
138	/**	138	/**
139	* tty_throttle_safe - flow control	139	* tty_throttle_safe - flow control
140	* @tty: terminal	140	* @tty: terminal
141	*	141	*
142	* Similar to tty_throttle() but will only attempt throttle	142	* Similar to tty_throttle() but will only attempt throttle
143	* if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental	143	* if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental
144	* throttle due to race conditions when throttling is conditional	144	* throttle due to race conditions when throttling is conditional
145	* on factors evaluated prior to throttling.	145	* on factors evaluated prior to throttling.
146	*	146	*
147	* Returns 0 if tty is throttled (or was already throttled)	147	* Returns 0 if tty is throttled (or was already throttled)
148	*/	148	*/
149		149
150	int tty_throttle_safe(struct tty_struct *tty)	150	int tty_throttle_safe(struct tty_struct *tty)
151	{	151	{
152	int ret = 0;	152	int ret = 0;
153		153
154	mutex_lock(&tty->throttle_mutex);	154	mutex_lock(&tty->throttle_mutex);
155	if (!test_bit(TTY_THROTTLED, &tty->flags)) {	155	if (!test_bit(TTY_THROTTLED, &tty->flags)) {
156	if (tty->flow_change != TTY_THROTTLE_SAFE)	156	if (tty->flow_change != TTY_THROTTLE_SAFE)
157	ret = 1;	157	ret = 1;
158	else {	158	else {
159	set_bit(TTY_THROTTLED, &tty->flags);	159	set_bit(TTY_THROTTLED, &tty->flags);
160	if (tty->ops->throttle)	160	if (tty->ops->throttle)
161	tty->ops->throttle(tty);	161	tty->ops->throttle(tty);
162	}	162	}
163	}	163	}
164	mutex_unlock(&tty->throttle_mutex);	164	mutex_unlock(&tty->throttle_mutex);
165		165
166	return ret;	166	return ret;
167	}	167	}
168		168
169	/**	169	/**
170	* tty_unthrottle_safe - flow control	170	* tty_unthrottle_safe - flow control
171	* @tty: terminal	171	* @tty: terminal
172	*	172	*
173	* Similar to tty_unthrottle() but will only attempt unthrottle	173	* Similar to tty_unthrottle() but will only attempt unthrottle
174	* if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental	174	* if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
175	* unthrottle due to race conditions when unthrottling is conditional	175	* unthrottle due to race conditions when unthrottling is conditional
176	* on factors evaluated prior to unthrottling.	176	* on factors evaluated prior to unthrottling.
177	*	177	*
178	* Returns 0 if tty is unthrottled (or was already unthrottled)	178	* Returns 0 if tty is unthrottled (or was already unthrottled)
179	*/	179	*/
180		180
181	int tty_unthrottle_safe(struct tty_struct *tty)	181	int tty_unthrottle_safe(struct tty_struct *tty)
182	{	182	{
183	int ret = 0;	183	int ret = 0;
184		184
185	mutex_lock(&tty->throttle_mutex);	185	mutex_lock(&tty->throttle_mutex);
186	if (test_bit(TTY_THROTTLED, &tty->flags)) {	186	if (test_bit(TTY_THROTTLED, &tty->flags)) {
187	if (tty->flow_change != TTY_UNTHROTTLE_SAFE)	187	if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
188	ret = 1;	188	ret = 1;
189	else {	189	else {
190	clear_bit(TTY_THROTTLED, &tty->flags);	190	clear_bit(TTY_THROTTLED, &tty->flags);
191	if (tty->ops->unthrottle)	191	if (tty->ops->unthrottle)
192	tty->ops->unthrottle(tty);	192	tty->ops->unthrottle(tty);
193	}	193	}
194	}	194	}
195	mutex_unlock(&tty->throttle_mutex);	195	mutex_unlock(&tty->throttle_mutex);
196		196
197	return ret;	197	return ret;
198	}	198	}
199		199
200	/**	200	/**
201	* tty_wait_until_sent - wait for I/O to finish	201	* tty_wait_until_sent - wait for I/O to finish
202	* @tty: tty we are waiting for	202	* @tty: tty we are waiting for
203	* @timeout: how long we will wait	203	* @timeout: how long we will wait
204	*	204	*
205	* Wait for characters pending in a tty driver to hit the wire, or	205	* Wait for characters pending in a tty driver to hit the wire, or
206	* for a timeout to occur (eg due to flow control)	206	* for a timeout to occur (eg due to flow control)
207	*	207	*
208	* Locking: none	208	* Locking: none
209	*/	209	*/
210		210
211	void tty_wait_until_sent(struct tty_struct *tty, long timeout)	211	void tty_wait_until_sent(struct tty_struct *tty, long timeout)
212	{	212	{
213	#ifdef TTY_DEBUG_WAIT_UNTIL_SENT	213	#ifdef TTY_DEBUG_WAIT_UNTIL_SENT
214	char buf[64];	214	char buf[64];
215		215
216	printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));	216	printk(KERN_DEBUG "%s wait until sent...\n", tty_name(tty, buf));
217	#endif	217	#endif
218	if (!timeout)	218	if (!timeout)
219	timeout = MAX_SCHEDULE_TIMEOUT;	219	timeout = MAX_SCHEDULE_TIMEOUT;
220	if (wait_event_interruptible_timeout(tty->write_wait,	220
221	!tty_chars_in_buffer(tty), timeout) >= 0) {	221	timeout = wait_event_interruptible_timeout(tty->write_wait,
222	if (tty->ops->wait_until_sent)	222	!tty_chars_in_buffer(tty), timeout);
223	tty->ops->wait_until_sent(tty, timeout);	223	if (timeout <= 0)
224	}	224	return;
		225
		226	if (timeout == MAX_SCHEDULE_TIMEOUT)
		227	timeout = 0;
		228
		229	if (tty->ops->wait_until_sent)
		230	tty->ops->wait_until_sent(tty, timeout);
225	}	231	}
226	EXPORT_SYMBOL(tty_wait_until_sent);	232	EXPORT_SYMBOL(tty_wait_until_sent);
227		233
228		234
229	/*	235	/*
230	* Termios Helper Methods	236	* Termios Helper Methods
231	*/	237	*/
232		238
233	static void unset_locked_termios(struct ktermios *termios,	239	static void unset_locked_termios(struct ktermios *termios,
234	struct ktermios *old,	240	struct ktermios *old,
235	struct ktermios *locked)	241	struct ktermios *locked)
236	{	242	{
237	int i;	243	int i;
238		244
239	#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) \| ((y) & (z)))	245	#define NOSET_MASK(x, y, z) (x = ((x) & ~(z)) \| ((y) & (z)))
240		246
241	if (!locked) {	247	if (!locked) {
242	printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");	248	printk(KERN_WARNING "Warning?!? termios_locked is NULL.\n");
243	return;	249	return;
244	}	250	}
245		251
246	NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);	252	NOSET_MASK(termios->c_iflag, old->c_iflag, locked->c_iflag);
247	NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);	253	NOSET_MASK(termios->c_oflag, old->c_oflag, locked->c_oflag);
248	NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);	254	NOSET_MASK(termios->c_cflag, old->c_cflag, locked->c_cflag);
249	NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);	255	NOSET_MASK(termios->c_lflag, old->c_lflag, locked->c_lflag);
250	termios->c_line = locked->c_line ? old->c_line : termios->c_line;	256	termios->c_line = locked->c_line ? old->c_line : termios->c_line;
251	for (i = 0; i < NCCS; i++)	257	for (i = 0; i < NCCS; i++)
252	termios->c_cc[i] = locked->c_cc[i] ?	258	termios->c_cc[i] = locked->c_cc[i] ?
253	old->c_cc[i] : termios->c_cc[i];	259	old->c_cc[i] : termios->c_cc[i];
254	/* FIXME: What should we do for i/ospeed */	260	/* FIXME: What should we do for i/ospeed */
255	}	261	}
256		262
257	/*	263	/*
258	* Routine which returns the baud rate of the tty	264	* Routine which returns the baud rate of the tty
259	*	265	*
260	* Note that the baud_table needs to be kept in sync with the	266	* Note that the baud_table needs to be kept in sync with the
261	* include/asm/termbits.h file.	267	* include/asm/termbits.h file.
262	*/	268	*/
263	static const speed_t baud_table[] = {	269	static const speed_t baud_table[] = {
264	0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,	270	0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
265	9600, 19200, 38400, 57600, 115200, 230400, 460800,	271	9600, 19200, 38400, 57600, 115200, 230400, 460800,
266	#ifdef __sparc__	272	#ifdef __sparc__
267	76800, 153600, 307200, 614400, 921600	273	76800, 153600, 307200, 614400, 921600
268	#else	274	#else
269	500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,	275	500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
270	2500000, 3000000, 3500000, 4000000	276	2500000, 3000000, 3500000, 4000000
271	#endif	277	#endif
272	};	278	};
273		279
274	#ifndef __sparc__	280	#ifndef __sparc__
275	static const tcflag_t baud_bits[] = {	281	static const tcflag_t baud_bits[] = {
276	B0, B50, B75, B110, B134, B150, B200, B300, B600,	282	B0, B50, B75, B110, B134, B150, B200, B300, B600,
277	B1200, B1800, B2400, B4800, B9600, B19200, B38400,	283	B1200, B1800, B2400, B4800, B9600, B19200, B38400,
278	B57600, B115200, B230400, B460800, B500000, B576000,	284	B57600, B115200, B230400, B460800, B500000, B576000,
279	B921600, B1000000, B1152000, B1500000, B2000000, B2500000,	285	B921600, B1000000, B1152000, B1500000, B2000000, B2500000,
280	B3000000, B3500000, B4000000	286	B3000000, B3500000, B4000000
281	};	287	};
282	#else	288	#else
283	static const tcflag_t baud_bits[] = {	289	static const tcflag_t baud_bits[] = {
284	B0, B50, B75, B110, B134, B150, B200, B300, B600,	290	B0, B50, B75, B110, B134, B150, B200, B300, B600,
285	B1200, B1800, B2400, B4800, B9600, B19200, B38400,	291	B1200, B1800, B2400, B4800, B9600, B19200, B38400,
286	B57600, B115200, B230400, B460800, B76800, B153600,	292	B57600, B115200, B230400, B460800, B76800, B153600,
287	B307200, B614400, B921600	293	B307200, B614400, B921600
288	};	294	};
289	#endif	295	#endif
290		296
291	static int n_baud_table = ARRAY_SIZE(baud_table);	297	static int n_baud_table = ARRAY_SIZE(baud_table);
292		298
293	/**	299	/**
294	* tty_termios_baud_rate	300	* tty_termios_baud_rate
295	* @termios: termios structure	301	* @termios: termios structure
296	*	302	*
297	* Convert termios baud rate data into a speed. This should be called	303	* Convert termios baud rate data into a speed. This should be called
298	* with the termios lock held if this termios is a terminal termios	304	* with the termios lock held if this termios is a terminal termios
299	* structure. May change the termios data. Device drivers can call this	305	* structure. May change the termios data. Device drivers can call this
300	* function but should use ->c_[io]speed directly as they are updated.	306	* function but should use ->c_[io]speed directly as they are updated.
301	*	307	*
302	* Locking: none	308	* Locking: none
303	*/	309	*/
304		310
305	speed_t tty_termios_baud_rate(struct ktermios *termios)	311	speed_t tty_termios_baud_rate(struct ktermios *termios)
306	{	312	{
307	unsigned int cbaud;	313	unsigned int cbaud;
308		314
309	cbaud = termios->c_cflag & CBAUD;	315	cbaud = termios->c_cflag & CBAUD;
310		316
311	#ifdef BOTHER	317	#ifdef BOTHER
312	/* Magic token for arbitrary speed via c_ispeed/c_ospeed */	318	/* Magic token for arbitrary speed via c_ispeed/c_ospeed */
313	if (cbaud == BOTHER)	319	if (cbaud == BOTHER)
314	return termios->c_ospeed;	320	return termios->c_ospeed;
315	#endif	321	#endif
316	if (cbaud & CBAUDEX) {	322	if (cbaud & CBAUDEX) {
317	cbaud &= ~CBAUDEX;	323	cbaud &= ~CBAUDEX;
318		324
319	if (cbaud < 1 \|\| cbaud + 15 > n_baud_table)	325	if (cbaud < 1 \|\| cbaud + 15 > n_baud_table)
320	termios->c_cflag &= ~CBAUDEX;	326	termios->c_cflag &= ~CBAUDEX;
321	else	327	else
322	cbaud += 15;	328	cbaud += 15;
323	}	329	}
324	return baud_table[cbaud];	330	return baud_table[cbaud];
325	}	331	}
326	EXPORT_SYMBOL(tty_termios_baud_rate);	332	EXPORT_SYMBOL(tty_termios_baud_rate);
327		333
328	/**	334	/**
329	* tty_termios_input_baud_rate	335	* tty_termios_input_baud_rate
330	* @termios: termios structure	336	* @termios: termios structure
331	*	337	*
332	* Convert termios baud rate data into a speed. This should be called	338	* Convert termios baud rate data into a speed. This should be called
333	* with the termios lock held if this termios is a terminal termios	339	* with the termios lock held if this termios is a terminal termios
334	* structure. May change the termios data. Device drivers can call this	340	* structure. May change the termios data. Device drivers can call this
335	* function but should use ->c_[io]speed directly as they are updated.	341	* function but should use ->c_[io]speed directly as they are updated.
336	*	342	*
337	* Locking: none	343	* Locking: none
338	*/	344	*/
339		345
340	speed_t tty_termios_input_baud_rate(struct ktermios *termios)	346	speed_t tty_termios_input_baud_rate(struct ktermios *termios)
341	{	347	{
342	#ifdef IBSHIFT	348	#ifdef IBSHIFT
343	unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;	349	unsigned int cbaud = (termios->c_cflag >> IBSHIFT) & CBAUD;
344		350
345	if (cbaud == B0)	351	if (cbaud == B0)
346	return tty_termios_baud_rate(termios);	352	return tty_termios_baud_rate(termios);
347		353
348	/* Magic token for arbitrary speed via c_ispeed*/	354	/* Magic token for arbitrary speed via c_ispeed*/
349	if (cbaud == BOTHER)	355	if (cbaud == BOTHER)
350	return termios->c_ispeed;	356	return termios->c_ispeed;
351		357
352	if (cbaud & CBAUDEX) {	358	if (cbaud & CBAUDEX) {
353	cbaud &= ~CBAUDEX;	359	cbaud &= ~CBAUDEX;
354		360
355	if (cbaud < 1 \|\| cbaud + 15 > n_baud_table)	361	if (cbaud < 1 \|\| cbaud + 15 > n_baud_table)
356	termios->c_cflag &= ~(CBAUDEX << IBSHIFT);	362	termios->c_cflag &= ~(CBAUDEX << IBSHIFT);
357	else	363	else
358	cbaud += 15;	364	cbaud += 15;
359	}	365	}
360	return baud_table[cbaud];	366	return baud_table[cbaud];
361	#else	367	#else
362	return tty_termios_baud_rate(termios);	368	return tty_termios_baud_rate(termios);
363	#endif	369	#endif
364	}	370	}
365	EXPORT_SYMBOL(tty_termios_input_baud_rate);	371	EXPORT_SYMBOL(tty_termios_input_baud_rate);
366		372
367	/**	373	/**
368	* tty_termios_encode_baud_rate	374	* tty_termios_encode_baud_rate
369	* @termios: ktermios structure holding user requested state	375	* @termios: ktermios structure holding user requested state
370	* @ispeed: input speed	376	* @ispeed: input speed
371	* @ospeed: output speed	377	* @ospeed: output speed
372	*	378	*
373	* Encode the speeds set into the passed termios structure. This is	379	* Encode the speeds set into the passed termios structure. This is
374	* used as a library helper for drivers so that they can report back	380	* used as a library helper for drivers so that they can report back
375	* the actual speed selected when it differs from the speed requested	381	* the actual speed selected when it differs from the speed requested
376	*	382	*
377	* For maximal back compatibility with legacy SYS5/POSIX *nix behaviour	383	* For maximal back compatibility with legacy SYS5/POSIX *nix behaviour
378	* we need to carefully set the bits when the user does not get the	384	* we need to carefully set the bits when the user does not get the
379	* desired speed. We allow small margins and preserve as much of possible	385	* desired speed. We allow small margins and preserve as much of possible
380	* of the input intent to keep compatibility.	386	* of the input intent to keep compatibility.
381	*	387	*
382	* Locking: Caller should hold termios lock. This is already held	388	* Locking: Caller should hold termios lock. This is already held
383	* when calling this function from the driver termios handler.	389	* when calling this function from the driver termios handler.
384	*	390	*
385	* The ifdefs deal with platforms whose owners have yet to update them	391	* The ifdefs deal with platforms whose owners have yet to update them
386	* and will all go away once this is done.	392	* and will all go away once this is done.
387	*/	393	*/
388		394
389	void tty_termios_encode_baud_rate(struct ktermios *termios,	395	void tty_termios_encode_baud_rate(struct ktermios *termios,
390	speed_t ibaud, speed_t obaud)	396	speed_t ibaud, speed_t obaud)
391	{	397	{
392	int i = 0;	398	int i = 0;
393	int ifound = -1, ofound = -1;	399	int ifound = -1, ofound = -1;
394	int iclose = ibaud/50, oclose = obaud/50;	400	int iclose = ibaud/50, oclose = obaud/50;
395	int ibinput = 0;	401	int ibinput = 0;
396		402
397	if (obaud == 0) /* CD dropped */	403	if (obaud == 0) /* CD dropped */
398	ibaud = 0; /* Clear ibaud to be sure */	404	ibaud = 0; /* Clear ibaud to be sure */
399		405
400	termios->c_ispeed = ibaud;	406	termios->c_ispeed = ibaud;
401	termios->c_ospeed = obaud;	407	termios->c_ospeed = obaud;
402		408
403	#ifdef BOTHER	409	#ifdef BOTHER
404	/* If the user asked for a precise weird speed give a precise weird	410	/* If the user asked for a precise weird speed give a precise weird
405	answer. If they asked for a Bfoo speed they may have problems	411	answer. If they asked for a Bfoo speed they may have problems
406	digesting non-exact replies so fuzz a bit */	412	digesting non-exact replies so fuzz a bit */
407		413
408	if ((termios->c_cflag & CBAUD) == BOTHER)	414	if ((termios->c_cflag & CBAUD) == BOTHER)
409	oclose = 0;	415	oclose = 0;
410	if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)	416	if (((termios->c_cflag >> IBSHIFT) & CBAUD) == BOTHER)
411	iclose = 0;	417	iclose = 0;
412	if ((termios->c_cflag >> IBSHIFT) & CBAUD)	418	if ((termios->c_cflag >> IBSHIFT) & CBAUD)
413	ibinput = 1; /* An input speed was specified */	419	ibinput = 1; /* An input speed was specified */
414	#endif	420	#endif
415	termios->c_cflag &= ~CBAUD;	421	termios->c_cflag &= ~CBAUD;
416		422
417	/*	423	/*
418	* Our goal is to find a close match to the standard baud rate	424	* Our goal is to find a close match to the standard baud rate
419	* returned. Walk the baud rate table and if we get a very close	425	* returned. Walk the baud rate table and if we get a very close
420	* match then report back the speed as a POSIX Bxxxx value by	426	* match then report back the speed as a POSIX Bxxxx value by
421	* preference	427	* preference
422	*/	428	*/
423		429
424	do {	430	do {
425	if (obaud - oclose <= baud_table[i] &&	431	if (obaud - oclose <= baud_table[i] &&
426	obaud + oclose >= baud_table[i]) {	432	obaud + oclose >= baud_table[i]) {
427	termios->c_cflag \|= baud_bits[i];	433	termios->c_cflag \|= baud_bits[i];
428	ofound = i;	434	ofound = i;
429	}	435	}
430	if (ibaud - iclose <= baud_table[i] &&	436	if (ibaud - iclose <= baud_table[i] &&
431	ibaud + iclose >= baud_table[i]) {	437	ibaud + iclose >= baud_table[i]) {
432	/* For the case input == output don't set IBAUD bits	438	/* For the case input == output don't set IBAUD bits
433	if the user didn't do so */	439	if the user didn't do so */
434	if (ofound == i && !ibinput)	440	if (ofound == i && !ibinput)
435	ifound = i;	441	ifound = i;
436	#ifdef IBSHIFT	442	#ifdef IBSHIFT
437	else {	443	else {
438	ifound = i;	444	ifound = i;
439	termios->c_cflag \|= (baud_bits[i] << IBSHIFT);	445	termios->c_cflag \|= (baud_bits[i] << IBSHIFT);
440	}	446	}
441	#endif	447	#endif
442	}	448	}
443	} while (++i < n_baud_table);	449	} while (++i < n_baud_table);
444		450
445	/*	451	/*
446	* If we found no match then use BOTHER if provided or warn	452	* If we found no match then use BOTHER if provided or warn
447	* the user their platform maintainer needs to wake up if not.	453	* the user their platform maintainer needs to wake up if not.
448	*/	454	*/
449	#ifdef BOTHER	455	#ifdef BOTHER
450	if (ofound == -1)	456	if (ofound == -1)
451	termios->c_cflag \|= BOTHER;	457	termios->c_cflag \|= BOTHER;
452	/* Set exact input bits only if the input and output differ or the	458	/* Set exact input bits only if the input and output differ or the
453	user already did */	459	user already did */
454	if (ifound == -1 && (ibaud != obaud \|\| ibinput))	460	if (ifound == -1 && (ibaud != obaud \|\| ibinput))
455	termios->c_cflag \|= (BOTHER << IBSHIFT);	461	termios->c_cflag \|= (BOTHER << IBSHIFT);
456	#else	462	#else
457	if (ifound == -1 \|\| ofound == -1) {	463	if (ifound == -1 \|\| ofound == -1) {
458	printk_once(KERN_WARNING "tty: Unable to return correct "	464	printk_once(KERN_WARNING "tty: Unable to return correct "
459	"speed data as your architecture needs updating.\n");	465	"speed data as your architecture needs updating.\n");
460	}	466	}
461	#endif	467	#endif
462	}	468	}
463	EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);	469	EXPORT_SYMBOL_GPL(tty_termios_encode_baud_rate);
464		470
465	/**	471	/**
466	* tty_encode_baud_rate - set baud rate of the tty	472	* tty_encode_baud_rate - set baud rate of the tty
467	* @ibaud: input baud rate	473	* @ibaud: input baud rate
468	* @obad: output baud rate	474	* @obad: output baud rate
469	*	475	*
470	* Update the current termios data for the tty with the new speed	476	* Update the current termios data for the tty with the new speed
471	* settings. The caller must hold the termios_rwsem for the tty in	477	* settings. The caller must hold the termios_rwsem for the tty in
472	* question.	478	* question.
473	*/	479	*/
474		480
475	void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)	481	void tty_encode_baud_rate(struct tty_struct *tty, speed_t ibaud, speed_t obaud)
476	{	482	{
477	tty_termios_encode_baud_rate(&tty->termios, ibaud, obaud);	483	tty_termios_encode_baud_rate(&tty->termios, ibaud, obaud);
478	}	484	}
479	EXPORT_SYMBOL_GPL(tty_encode_baud_rate);	485	EXPORT_SYMBOL_GPL(tty_encode_baud_rate);
480		486
481	/**	487	/**
482	* tty_termios_copy_hw - copy hardware settings	488	* tty_termios_copy_hw - copy hardware settings
483	* @new: New termios	489	* @new: New termios
484	* @old: Old termios	490	* @old: Old termios
485	*	491	*
486	* Propagate the hardware specific terminal setting bits from	492	* Propagate the hardware specific terminal setting bits from
487	* the old termios structure to the new one. This is used in cases	493	* the old termios structure to the new one. This is used in cases
488	* where the hardware does not support reconfiguration or as a helper	494	* where the hardware does not support reconfiguration or as a helper
489	* in some cases where only minimal reconfiguration is supported	495	* in some cases where only minimal reconfiguration is supported
490	*/	496	*/
491		497
492	void tty_termios_copy_hw(struct ktermios new, struct ktermios old)	498	void tty_termios_copy_hw(struct ktermios new, struct ktermios old)
493	{	499	{
494	/* The bits a dumb device handles in software. Smart devices need	500	/* The bits a dumb device handles in software. Smart devices need
495	to always provide a set_termios method */	501	to always provide a set_termios method */
496	new->c_cflag &= HUPCL \| CREAD \| CLOCAL;	502	new->c_cflag &= HUPCL \| CREAD \| CLOCAL;
497	new->c_cflag \|= old->c_cflag & ~(HUPCL \| CREAD \| CLOCAL);	503	new->c_cflag \|= old->c_cflag & ~(HUPCL \| CREAD \| CLOCAL);
498	new->c_ispeed = old->c_ispeed;	504	new->c_ispeed = old->c_ispeed;
499	new->c_ospeed = old->c_ospeed;	505	new->c_ospeed = old->c_ospeed;
500	}	506	}
501	EXPORT_SYMBOL(tty_termios_copy_hw);	507	EXPORT_SYMBOL(tty_termios_copy_hw);
502		508
503	/**	509	/**
504	* tty_termios_hw_change - check for setting change	510	* tty_termios_hw_change - check for setting change
505	* @a: termios	511	* @a: termios
506	* @b: termios to compare	512	* @b: termios to compare
507	*	513	*
508	* Check if any of the bits that affect a dumb device have changed	514	* Check if any of the bits that affect a dumb device have changed
509	* between the two termios structures, or a speed change is needed.	515	* between the two termios structures, or a speed change is needed.
510	*/	516	*/
511		517
512	int tty_termios_hw_change(struct ktermios a, struct ktermios b)	518	int tty_termios_hw_change(struct ktermios a, struct ktermios b)
513	{	519	{
514	if (a->c_ispeed != b->c_ispeed \|\| a->c_ospeed != b->c_ospeed)	520	if (a->c_ispeed != b->c_ispeed \|\| a->c_ospeed != b->c_ospeed)
515	return 1;	521	return 1;
516	if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL \| CREAD \| CLOCAL))	522	if ((a->c_cflag ^ b->c_cflag) & ~(HUPCL \| CREAD \| CLOCAL))
517	return 1;	523	return 1;
518	return 0;	524	return 0;
519	}	525	}
520	EXPORT_SYMBOL(tty_termios_hw_change);	526	EXPORT_SYMBOL(tty_termios_hw_change);
521		527
522	/**	528	/**
523	* tty_set_termios - update termios values	529	* tty_set_termios - update termios values
524	* @tty: tty to update	530	* @tty: tty to update
525	* @new_termios: desired new value	531	* @new_termios: desired new value
526	*	532	*
527	* Perform updates to the termios values set on this terminal.	533	* Perform updates to the termios values set on this terminal.
528	* A master pty's termios should never be set.	534	* A master pty's termios should never be set.
529	*	535	*
530	* Locking: termios_rwsem	536	* Locking: termios_rwsem
531	*/	537	*/
532		538
533	static int tty_set_termios(struct tty_struct tty, struct ktermios new_termios)	539	static int tty_set_termios(struct tty_struct tty, struct ktermios new_termios)
534	{	540	{
535	struct ktermios old_termios;	541	struct ktermios old_termios;
536	struct tty_ldisc *ld;	542	struct tty_ldisc *ld;
537		543
538	WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&	544	WARN_ON(tty->driver->type == TTY_DRIVER_TYPE_PTY &&
539	tty->driver->subtype == PTY_TYPE_MASTER);	545	tty->driver->subtype == PTY_TYPE_MASTER);
540	/*	546	/*
541	* Perform the actual termios internal changes under lock.	547	* Perform the actual termios internal changes under lock.
542	*/	548	*/
543		549
544		550
545	/* FIXME: we need to decide on some locking/ordering semantics	551	/* FIXME: we need to decide on some locking/ordering semantics
546	for the set_termios notification eventually */	552	for the set_termios notification eventually */
547	down_write(&tty->termios_rwsem);	553	down_write(&tty->termios_rwsem);
548	old_termios = tty->termios;	554	old_termios = tty->termios;
549	tty->termios = *new_termios;	555	tty->termios = *new_termios;
550	unset_locked_termios(&tty->termios, &old_termios, &tty->termios_locked);	556	unset_locked_termios(&tty->termios, &old_termios, &tty->termios_locked);
551		557
552	if (tty->ops->set_termios)	558	if (tty->ops->set_termios)
553	tty->ops->set_termios(tty, &old_termios);	559	tty->ops->set_termios(tty, &old_termios);
554	else	560	else
555	tty_termios_copy_hw(&tty->termios, &old_termios);	561	tty_termios_copy_hw(&tty->termios, &old_termios);
556		562
557	ld = tty_ldisc_ref(tty);	563	ld = tty_ldisc_ref(tty);
558	if (ld != NULL) {	564	if (ld != NULL) {
559	if (ld->ops->set_termios)	565	if (ld->ops->set_termios)
560	ld->ops->set_termios(tty, &old_termios);	566	ld->ops->set_termios(tty, &old_termios);
561	tty_ldisc_deref(ld);	567	tty_ldisc_deref(ld);
562	}	568	}
563	up_write(&tty->termios_rwsem);	569	up_write(&tty->termios_rwsem);
564	return 0;	570	return 0;
565	}	571	}
566		572
567	/**	573	/**
568	* set_termios - set termios values for a tty	574	* set_termios - set termios values for a tty
569	* @tty: terminal device	575	* @tty: terminal device
570	* @arg: user data	576	* @arg: user data
571	* @opt: option information	577	* @opt: option information
572	*	578	*
573	* Helper function to prepare termios data and run necessary other	579	* Helper function to prepare termios data and run necessary other
574	* functions before using tty_set_termios to do the actual changes.	580	* functions before using tty_set_termios to do the actual changes.
575	*	581	*
576	* Locking:	582	* Locking:
577	* Called functions take ldisc and termios_rwsem locks	583	* Called functions take ldisc and termios_rwsem locks
578	*/	584	*/
579		585
580	static int set_termios(struct tty_struct tty, void __user arg, int opt)	586	static int set_termios(struct tty_struct tty, void __user arg, int opt)
581	{	587	{
582	struct ktermios tmp_termios;	588	struct ktermios tmp_termios;
583	struct tty_ldisc *ld;	589	struct tty_ldisc *ld;
584	int retval = tty_check_change(tty);	590	int retval = tty_check_change(tty);
585		591
586	if (retval)	592	if (retval)
587	return retval;	593	return retval;
588		594
589	down_read(&tty->termios_rwsem);	595	down_read(&tty->termios_rwsem);
590	tmp_termios = tty->termios;	596	tmp_termios = tty->termios;
591	up_read(&tty->termios_rwsem);	597	up_read(&tty->termios_rwsem);
592		598
593	if (opt & TERMIOS_TERMIO) {	599	if (opt & TERMIOS_TERMIO) {
594	if (user_termio_to_kernel_termios(&tmp_termios,	600	if (user_termio_to_kernel_termios(&tmp_termios,
595	(struct termio __user *)arg))	601	(struct termio __user *)arg))
596	return -EFAULT;	602	return -EFAULT;
597	#ifdef TCGETS2	603	#ifdef TCGETS2
598	} else if (opt & TERMIOS_OLD) {	604	} else if (opt & TERMIOS_OLD) {
599	if (user_termios_to_kernel_termios_1(&tmp_termios,	605	if (user_termios_to_kernel_termios_1(&tmp_termios,
600	(struct termios __user *)arg))	606	(struct termios __user *)arg))
601	return -EFAULT;	607	return -EFAULT;
602	} else {	608	} else {
603	if (user_termios_to_kernel_termios(&tmp_termios,	609	if (user_termios_to_kernel_termios(&tmp_termios,
604	(struct termios2 __user *)arg))	610	(struct termios2 __user *)arg))
605	return -EFAULT;	611	return -EFAULT;
606	}	612	}
607	#else	613	#else
608	} else if (user_termios_to_kernel_termios(&tmp_termios,	614	} else if (user_termios_to_kernel_termios(&tmp_termios,
609	(struct termios __user *)arg))	615	(struct termios __user *)arg))
610	return -EFAULT;	616	return -EFAULT;
611	#endif	617	#endif
612		618
613	/* If old style Bfoo values are used then load c_ispeed/c_ospeed	619	/* If old style Bfoo values are used then load c_ispeed/c_ospeed
614	* with the real speed so its unconditionally usable */	620	* with the real speed so its unconditionally usable */
615	tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);	621	tmp_termios.c_ispeed = tty_termios_input_baud_rate(&tmp_termios);
616	tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);	622	tmp_termios.c_ospeed = tty_termios_baud_rate(&tmp_termios);
617		623
618	ld = tty_ldisc_ref(tty);	624	ld = tty_ldisc_ref(tty);
619		625
620	if (ld != NULL) {	626	if (ld != NULL) {
621	if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)	627	if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
622	ld->ops->flush_buffer(tty);	628	ld->ops->flush_buffer(tty);
623	tty_ldisc_deref(ld);	629	tty_ldisc_deref(ld);
624	}	630	}
625		631
626	if (opt & TERMIOS_WAIT) {	632	if (opt & TERMIOS_WAIT) {
627	tty_wait_until_sent(tty, 0);	633	tty_wait_until_sent(tty, 0);
628	if (signal_pending(current))	634	if (signal_pending(current))
629	return -ERESTARTSYS;	635	return -ERESTARTSYS;
630	}	636	}
631		637
632	tty_set_termios(tty, &tmp_termios);	638	tty_set_termios(tty, &tmp_termios);
633		639
634	/* FIXME: Arguably if tmp_termios == tty->termios AND the	640	/* FIXME: Arguably if tmp_termios == tty->termios AND the
635	actual requested termios was not tmp_termios then we may	641	actual requested termios was not tmp_termios then we may
636	want to return an error as no user requested change has	642	want to return an error as no user requested change has
637	succeeded */	643	succeeded */
638	return 0;	644	return 0;
639	}	645	}
640		646
641	static void copy_termios(struct tty_struct tty, struct ktermios kterm)	647	static void copy_termios(struct tty_struct tty, struct ktermios kterm)
642	{	648	{
643	down_read(&tty->termios_rwsem);	649	down_read(&tty->termios_rwsem);
644	*kterm = tty->termios;	650	*kterm = tty->termios;
645	up_read(&tty->termios_rwsem);	651	up_read(&tty->termios_rwsem);
646	}	652	}
647		653
648	static void copy_termios_locked(struct tty_struct tty, struct ktermios kterm)	654	static void copy_termios_locked(struct tty_struct tty, struct ktermios kterm)
649	{	655	{
650	down_read(&tty->termios_rwsem);	656	down_read(&tty->termios_rwsem);
651	*kterm = tty->termios_locked;	657	*kterm = tty->termios_locked;
652	up_read(&tty->termios_rwsem);	658	up_read(&tty->termios_rwsem);
653	}	659	}
654		660
655	static int get_termio(struct tty_struct tty, struct termio __user termio)	661	static int get_termio(struct tty_struct tty, struct termio __user termio)
656	{	662	{
657	struct ktermios kterm;	663	struct ktermios kterm;
658	copy_termios(tty, &kterm);	664	copy_termios(tty, &kterm);
659	if (kernel_termios_to_user_termio(termio, &kterm))	665	if (kernel_termios_to_user_termio(termio, &kterm))
660	return -EFAULT;	666	return -EFAULT;
661	return 0;	667	return 0;
662	}	668	}
663		669
664		670
665	#ifdef TCGETX	671	#ifdef TCGETX
666		672
667	/**	673	/**
668	* set_termiox - set termiox fields if possible	674	* set_termiox - set termiox fields if possible
669	* @tty: terminal	675	* @tty: terminal
670	* @arg: termiox structure from user	676	* @arg: termiox structure from user
671	* @opt: option flags for ioctl type	677	* @opt: option flags for ioctl type
672	*	678	*
673	* Implement the device calling points for the SYS5 termiox ioctl	679	* Implement the device calling points for the SYS5 termiox ioctl
674	* interface in Linux	680	* interface in Linux
675	*/	681	*/
676		682
677	static int set_termiox(struct tty_struct tty, void __user arg, int opt)	683	static int set_termiox(struct tty_struct tty, void __user arg, int opt)
678	{	684	{
679	struct termiox tnew;	685	struct termiox tnew;
680	struct tty_ldisc *ld;	686	struct tty_ldisc *ld;
681		687
682	if (tty->termiox == NULL)	688	if (tty->termiox == NULL)
683	return -EINVAL;	689	return -EINVAL;
684	if (copy_from_user(&tnew, arg, sizeof(struct termiox)))	690	if (copy_from_user(&tnew, arg, sizeof(struct termiox)))
685	return -EFAULT;	691	return -EFAULT;
686		692
687	ld = tty_ldisc_ref(tty);	693	ld = tty_ldisc_ref(tty);
688	if (ld != NULL) {	694	if (ld != NULL) {
689	if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)	695	if ((opt & TERMIOS_FLUSH) && ld->ops->flush_buffer)
690	ld->ops->flush_buffer(tty);	696	ld->ops->flush_buffer(tty);
691	tty_ldisc_deref(ld);	697	tty_ldisc_deref(ld);
692	}	698	}
693	if (opt & TERMIOS_WAIT) {	699	if (opt & TERMIOS_WAIT) {
694	tty_wait_until_sent(tty, 0);	700	tty_wait_until_sent(tty, 0);
695	if (signal_pending(current))	701	if (signal_pending(current))
696	return -ERESTARTSYS;	702	return -ERESTARTSYS;
697	}	703	}
698		704
699	down_write(&tty->termios_rwsem);	705	down_write(&tty->termios_rwsem);
700	if (tty->ops->set_termiox)	706	if (tty->ops->set_termiox)
701	tty->ops->set_termiox(tty, &tnew);	707	tty->ops->set_termiox(tty, &tnew);
702	up_write(&tty->termios_rwsem);	708	up_write(&tty->termios_rwsem);
703	return 0;	709	return 0;
704	}	710	}
705		711
706	#endif	712	#endif
707		713
708		714
709	#ifdef TIOCGETP	715	#ifdef TIOCGETP
710	/*	716	/*
711	* These are deprecated, but there is limited support..	717	* These are deprecated, but there is limited support..
712	*	718	*
713	* The "sg_flags" translation is a joke..	719	* The "sg_flags" translation is a joke..
714	*/	720	*/
715	static int get_sgflags(struct tty_struct *tty)	721	static int get_sgflags(struct tty_struct *tty)
716	{	722	{
717	int flags = 0;	723	int flags = 0;
718		724
719	if (!(tty->termios.c_lflag & ICANON)) {	725	if (!(tty->termios.c_lflag & ICANON)) {
720	if (tty->termios.c_lflag & ISIG)	726	if (tty->termios.c_lflag & ISIG)
721	flags \|= 0x02; /* cbreak */	727	flags \|= 0x02; /* cbreak */
722	else	728	else
723	flags \|= 0x20; /* raw */	729	flags \|= 0x20; /* raw */
724	}	730	}
725	if (tty->termios.c_lflag & ECHO)	731	if (tty->termios.c_lflag & ECHO)
726	flags \|= 0x08; /* echo */	732	flags \|= 0x08; /* echo */
727	if (tty->termios.c_oflag & OPOST)	733	if (tty->termios.c_oflag & OPOST)
728	if (tty->termios.c_oflag & ONLCR)	734	if (tty->termios.c_oflag & ONLCR)
729	flags \|= 0x10; /* crmod */	735	flags \|= 0x10; /* crmod */
730	return flags;	736	return flags;
731	}	737	}
732		738
733	static int get_sgttyb(struct tty_struct tty, struct sgttyb __user sgttyb)	739	static int get_sgttyb(struct tty_struct tty, struct sgttyb __user sgttyb)
734	{	740	{
735	struct sgttyb tmp;	741	struct sgttyb tmp;
736		742
737	down_read(&tty->termios_rwsem);	743	down_read(&tty->termios_rwsem);
738	tmp.sg_ispeed = tty->termios.c_ispeed;	744	tmp.sg_ispeed = tty->termios.c_ispeed;
739	tmp.sg_ospeed = tty->termios.c_ospeed;	745	tmp.sg_ospeed = tty->termios.c_ospeed;
740	tmp.sg_erase = tty->termios.c_cc[VERASE];	746	tmp.sg_erase = tty->termios.c_cc[VERASE];
741	tmp.sg_kill = tty->termios.c_cc[VKILL];	747	tmp.sg_kill = tty->termios.c_cc[VKILL];
742	tmp.sg_flags = get_sgflags(tty);	748	tmp.sg_flags = get_sgflags(tty);
743	up_read(&tty->termios_rwsem);	749	up_read(&tty->termios_rwsem);
744		750
745	return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;	751	return copy_to_user(sgttyb, &tmp, sizeof(tmp)) ? -EFAULT : 0;
746	}	752	}
747		753
748	static void set_sgflags(struct ktermios *termios, int flags)	754	static void set_sgflags(struct ktermios *termios, int flags)
749	{	755	{
750	termios->c_iflag = ICRNL \| IXON;	756	termios->c_iflag = ICRNL \| IXON;
751	termios->c_oflag = 0;	757	termios->c_oflag = 0;
752	termios->c_lflag = ISIG \| ICANON;	758	termios->c_lflag = ISIG \| ICANON;
753	if (flags & 0x02) { /* cbreak */	759	if (flags & 0x02) { /* cbreak */
754	termios->c_iflag = 0;	760	termios->c_iflag = 0;
755	termios->c_lflag &= ~ICANON;	761	termios->c_lflag &= ~ICANON;
756	}	762	}
757	if (flags & 0x08) { /* echo */	763	if (flags & 0x08) { /* echo */
758	termios->c_lflag \|= ECHO \| ECHOE \| ECHOK \|	764	termios->c_lflag \|= ECHO \| ECHOE \| ECHOK \|
759	ECHOCTL \| ECHOKE \| IEXTEN;	765	ECHOCTL \| ECHOKE \| IEXTEN;
760	}	766	}
761	if (flags & 0x10) { /* crmod */	767	if (flags & 0x10) { /* crmod */
762	termios->c_oflag \|= OPOST \| ONLCR;	768	termios->c_oflag \|= OPOST \| ONLCR;
763	}	769	}
764	if (flags & 0x20) { /* raw */	770	if (flags & 0x20) { /* raw */
765	termios->c_iflag = 0;	771	termios->c_iflag = 0;
766	termios->c_lflag &= ~(ISIG \| ICANON);	772	termios->c_lflag &= ~(ISIG \| ICANON);
767	}	773	}
768	if (!(termios->c_lflag & ICANON)) {	774	if (!(termios->c_lflag & ICANON)) {
769	termios->c_cc[VMIN] = 1;	775	termios->c_cc[VMIN] = 1;
770	termios->c_cc[VTIME] = 0;	776	termios->c_cc[VTIME] = 0;
771	}	777	}
772	}	778	}
773		779
774	/**	780	/**
775	* set_sgttyb - set legacy terminal values	781	* set_sgttyb - set legacy terminal values
776	* @tty: tty structure	782	* @tty: tty structure
777	* @sgttyb: pointer to old style terminal structure	783	* @sgttyb: pointer to old style terminal structure
778	*	784	*
779	* Updates a terminal from the legacy BSD style terminal information	785	* Updates a terminal from the legacy BSD style terminal information
780	* structure.	786	* structure.
781	*	787	*
782	* Locking: termios_rwsem	788	* Locking: termios_rwsem
783	*/	789	*/
784		790
785	static int set_sgttyb(struct tty_struct tty, struct sgttyb __user sgttyb)	791	static int set_sgttyb(struct tty_struct tty, struct sgttyb __user sgttyb)
786	{	792	{
787	int retval;	793	int retval;
788	struct sgttyb tmp;	794	struct sgttyb tmp;
789	struct ktermios termios;	795	struct ktermios termios;
790		796
791	retval = tty_check_change(tty);	797	retval = tty_check_change(tty);
792	if (retval)	798	if (retval)
793	return retval;	799	return retval;
794		800
795	if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))	801	if (copy_from_user(&tmp, sgttyb, sizeof(tmp)))
796	return -EFAULT;	802	return -EFAULT;
797		803
798	down_write(&tty->termios_rwsem);	804	down_write(&tty->termios_rwsem);
799	termios = tty->termios;	805	termios = tty->termios;
800	termios.c_cc[VERASE] = tmp.sg_erase;	806	termios.c_cc[VERASE] = tmp.sg_erase;
801	termios.c_cc[VKILL] = tmp.sg_kill;	807	termios.c_cc[VKILL] = tmp.sg_kill;
802	set_sgflags(&termios, tmp.sg_flags);	808	set_sgflags(&termios, tmp.sg_flags);
803	/* Try and encode into Bfoo format */	809	/* Try and encode into Bfoo format */
804	#ifdef BOTHER	810	#ifdef BOTHER
805	tty_termios_encode_baud_rate(&termios, termios.c_ispeed,	811	tty_termios_encode_baud_rate(&termios, termios.c_ispeed,
806	termios.c_ospeed);	812	termios.c_ospeed);
807	#endif	813	#endif
808	up_write(&tty->termios_rwsem);	814	up_write(&tty->termios_rwsem);
809	tty_set_termios(tty, &termios);	815	tty_set_termios(tty, &termios);
810	return 0;	816	return 0;
811	}	817	}
812	#endif	818	#endif
813		819
814	#ifdef TIOCGETC	820	#ifdef TIOCGETC
815	static int get_tchars(struct tty_struct tty, struct tchars __user tchars)	821	static int get_tchars(struct tty_struct tty, struct tchars __user tchars)
816	{	822	{
817	struct tchars tmp;	823	struct tchars tmp;
818		824
819	down_read(&tty->termios_rwsem);	825	down_read(&tty->termios_rwsem);
820	tmp.t_intrc = tty->termios.c_cc[VINTR];	826	tmp.t_intrc = tty->termios.c_cc[VINTR];
821	tmp.t_quitc = tty->termios.c_cc[VQUIT];	827	tmp.t_quitc = tty->termios.c_cc[VQUIT];
822	tmp.t_startc = tty->termios.c_cc[VSTART];	828	tmp.t_startc = tty->termios.c_cc[VSTART];
823	tmp.t_stopc = tty->termios.c_cc[VSTOP];	829	tmp.t_stopc = tty->termios.c_cc[VSTOP];
824	tmp.t_eofc = tty->termios.c_cc[VEOF];	830	tmp.t_eofc = tty->termios.c_cc[VEOF];
825	tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */	831	tmp.t_brkc = tty->termios.c_cc[VEOL2]; /* what is brkc anyway? */
826	up_read(&tty->termios_rwsem);	832	up_read(&tty->termios_rwsem);
827	return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;	833	return copy_to_user(tchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
828	}	834	}
829		835
830	static int set_tchars(struct tty_struct tty, struct tchars __user tchars)	836	static int set_tchars(struct tty_struct tty, struct tchars __user tchars)
831	{	837	{
832	struct tchars tmp;	838	struct tchars tmp;
833		839
834	if (copy_from_user(&tmp, tchars, sizeof(tmp)))	840	if (copy_from_user(&tmp, tchars, sizeof(tmp)))
835	return -EFAULT;	841	return -EFAULT;
836	down_write(&tty->termios_rwsem);	842	down_write(&tty->termios_rwsem);
837	tty->termios.c_cc[VINTR] = tmp.t_intrc;	843	tty->termios.c_cc[VINTR] = tmp.t_intrc;
838	tty->termios.c_cc[VQUIT] = tmp.t_quitc;	844	tty->termios.c_cc[VQUIT] = tmp.t_quitc;
839	tty->termios.c_cc[VSTART] = tmp.t_startc;	845	tty->termios.c_cc[VSTART] = tmp.t_startc;
840	tty->termios.c_cc[VSTOP] = tmp.t_stopc;	846	tty->termios.c_cc[VSTOP] = tmp.t_stopc;
841	tty->termios.c_cc[VEOF] = tmp.t_eofc;	847	tty->termios.c_cc[VEOF] = tmp.t_eofc;
842	tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */	848	tty->termios.c_cc[VEOL2] = tmp.t_brkc; /* what is brkc anyway? */
843	up_write(&tty->termios_rwsem);	849	up_write(&tty->termios_rwsem);
844	return 0;	850	return 0;
845	}	851	}
846	#endif	852	#endif
847		853
848	#ifdef TIOCGLTC	854	#ifdef TIOCGLTC
849	static int get_ltchars(struct tty_struct tty, struct ltchars __user ltchars)	855	static int get_ltchars(struct tty_struct tty, struct ltchars __user ltchars)
850	{	856	{
851	struct ltchars tmp;	857	struct ltchars tmp;
852		858
853	down_read(&tty->termios_rwsem);	859	down_read(&tty->termios_rwsem);
854	tmp.t_suspc = tty->termios.c_cc[VSUSP];	860	tmp.t_suspc = tty->termios.c_cc[VSUSP];
855	/* what is dsuspc anyway? */	861	/* what is dsuspc anyway? */
856	tmp.t_dsuspc = tty->termios.c_cc[VSUSP];	862	tmp.t_dsuspc = tty->termios.c_cc[VSUSP];
857	tmp.t_rprntc = tty->termios.c_cc[VREPRINT];	863	tmp.t_rprntc = tty->termios.c_cc[VREPRINT];
858	/* what is flushc anyway? */	864	/* what is flushc anyway? */
859	tmp.t_flushc = tty->termios.c_cc[VEOL2];	865	tmp.t_flushc = tty->termios.c_cc[VEOL2];
860	tmp.t_werasc = tty->termios.c_cc[VWERASE];	866	tmp.t_werasc = tty->termios.c_cc[VWERASE];
861	tmp.t_lnextc = tty->termios.c_cc[VLNEXT];	867	tmp.t_lnextc = tty->termios.c_cc[VLNEXT];
862	up_read(&tty->termios_rwsem);	868	up_read(&tty->termios_rwsem);
863	return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;	869	return copy_to_user(ltchars, &tmp, sizeof(tmp)) ? -EFAULT : 0;
864	}	870	}
865		871
866	static int set_ltchars(struct tty_struct tty, struct ltchars __user ltchars)	872	static int set_ltchars(struct tty_struct tty, struct ltchars __user ltchars)
867	{	873	{
868	struct ltchars tmp;	874	struct ltchars tmp;
869		875
870	if (copy_from_user(&tmp, ltchars, sizeof(tmp)))	876	if (copy_from_user(&tmp, ltchars, sizeof(tmp)))
871	return -EFAULT;	877	return -EFAULT;
872		878
873	down_write(&tty->termios_rwsem);	879	down_write(&tty->termios_rwsem);
874	tty->termios.c_cc[VSUSP] = tmp.t_suspc;	880	tty->termios.c_cc[VSUSP] = tmp.t_suspc;
875	/* what is dsuspc anyway? */	881	/* what is dsuspc anyway? */
876	tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;	882	tty->termios.c_cc[VEOL2] = tmp.t_dsuspc;
877	tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;	883	tty->termios.c_cc[VREPRINT] = tmp.t_rprntc;
878	/* what is flushc anyway? */	884	/* what is flushc anyway? */
879	tty->termios.c_cc[VEOL2] = tmp.t_flushc;	885	tty->termios.c_cc[VEOL2] = tmp.t_flushc;
880	tty->termios.c_cc[VWERASE] = tmp.t_werasc;	886	tty->termios.c_cc[VWERASE] = tmp.t_werasc;
881	tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;	887	tty->termios.c_cc[VLNEXT] = tmp.t_lnextc;
882	up_write(&tty->termios_rwsem);	888	up_write(&tty->termios_rwsem);
883	return 0;	889	return 0;
884	}	890	}
885	#endif	891	#endif
886		892
887	/**	893	/**
888	* tty_change_softcar - carrier change ioctl helper	894	* tty_change_softcar - carrier change ioctl helper
889	* @tty: tty to update	895	* @tty: tty to update
890	* @arg: enable/disable CLOCAL	896	* @arg: enable/disable CLOCAL
891	*	897	*
892	* Perform a change to the CLOCAL state and call into the driver	898	* Perform a change to the CLOCAL state and call into the driver
893	* layer to make it visible. All done with the termios rwsem	899	* layer to make it visible. All done with the termios rwsem
894	*/	900	*/
895		901
896	static int tty_change_softcar(struct tty_struct *tty, int arg)	902	static int tty_change_softcar(struct tty_struct *tty, int arg)
897	{	903	{
898	int ret = 0;	904	int ret = 0;
899	int bit = arg ? CLOCAL : 0;	905	int bit = arg ? CLOCAL : 0;
900	struct ktermios old;	906	struct ktermios old;
901		907
902	down_write(&tty->termios_rwsem);	908	down_write(&tty->termios_rwsem);
903	old = tty->termios;	909	old = tty->termios;
904	tty->termios.c_cflag &= ~CLOCAL;	910	tty->termios.c_cflag &= ~CLOCAL;
905	tty->termios.c_cflag \|= bit;	911	tty->termios.c_cflag \|= bit;
906	if (tty->ops->set_termios)	912	if (tty->ops->set_termios)
907	tty->ops->set_termios(tty, &old);	913	tty->ops->set_termios(tty, &old);
908	if ((tty->termios.c_cflag & CLOCAL) != bit)	914	if ((tty->termios.c_cflag & CLOCAL) != bit)
909	ret = -EINVAL;	915	ret = -EINVAL;
910	up_write(&tty->termios_rwsem);	916	up_write(&tty->termios_rwsem);
911	return ret;	917	return ret;
912	}	918	}
913		919
914	/**	920	/**
915	* tty_mode_ioctl - mode related ioctls	921	* tty_mode_ioctl - mode related ioctls
916	* @tty: tty for the ioctl	922	* @tty: tty for the ioctl
917	* @file: file pointer for the tty	923	* @file: file pointer for the tty
918	* @cmd: command	924	* @cmd: command
919	* @arg: ioctl argument	925	* @arg: ioctl argument
920	*	926	*
921	* Perform non line discipline specific mode control ioctls. This	927	* Perform non line discipline specific mode control ioctls. This
922	* is designed to be called by line disciplines to ensure they provide	928	* is designed to be called by line disciplines to ensure they provide
923	* consistent mode setting.	929	* consistent mode setting.
924	*/	930	*/
925		931
926	int tty_mode_ioctl(struct tty_struct tty, struct file file,	932	int tty_mode_ioctl(struct tty_struct tty, struct file file,
927	unsigned int cmd, unsigned long arg)	933	unsigned int cmd, unsigned long arg)
928	{	934	{
929	struct tty_struct *real_tty;	935	struct tty_struct *real_tty;
930	void __user p = (void __user )arg;	936	void __user p = (void __user )arg;
931	int ret = 0;	937	int ret = 0;
932	struct ktermios kterm;	938	struct ktermios kterm;
933		939
934	BUG_ON(file == NULL);	940	BUG_ON(file == NULL);
935		941
936	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&	942	if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
937	tty->driver->subtype == PTY_TYPE_MASTER)	943	tty->driver->subtype == PTY_TYPE_MASTER)
938	real_tty = tty->link;	944	real_tty = tty->link;
939	else	945	else
940	real_tty = tty;	946	real_tty = tty;
941		947
942	switch (cmd) {	948	switch (cmd) {
943	#ifdef TIOCGETP	949	#ifdef TIOCGETP
944	case TIOCGETP:	950	case TIOCGETP:
945	return get_sgttyb(real_tty, (struct sgttyb __user *) arg);	951	return get_sgttyb(real_tty, (struct sgttyb __user *) arg);
946	case TIOCSETP:	952	case TIOCSETP:
947	case TIOCSETN:	953	case TIOCSETN:
948	return set_sgttyb(real_tty, (struct sgttyb __user *) arg);	954	return set_sgttyb(real_tty, (struct sgttyb __user *) arg);
949	#endif	955	#endif
950	#ifdef TIOCGETC	956	#ifdef TIOCGETC
951	case TIOCGETC:	957	case TIOCGETC:
952	return get_tchars(real_tty, p);	958	return get_tchars(real_tty, p);
953	case TIOCSETC:	959	case TIOCSETC:
954	return set_tchars(real_tty, p);	960	return set_tchars(real_tty, p);
955	#endif	961	#endif
956	#ifdef TIOCGLTC	962	#ifdef TIOCGLTC
957	case TIOCGLTC:	963	case TIOCGLTC:
958	return get_ltchars(real_tty, p);	964	return get_ltchars(real_tty, p);
959	case TIOCSLTC:	965	case TIOCSLTC:
960	return set_ltchars(real_tty, p);	966	return set_ltchars(real_tty, p);
961	#endif	967	#endif
962	case TCSETSF:	968	case TCSETSF:
963	return set_termios(real_tty, p, TERMIOS_FLUSH \| TERMIOS_WAIT \| TERMIOS_OLD);	969	return set_termios(real_tty, p, TERMIOS_FLUSH \| TERMIOS_WAIT \| TERMIOS_OLD);
964	case TCSETSW:	970	case TCSETSW:
965	return set_termios(real_tty, p, TERMIOS_WAIT \| TERMIOS_OLD);	971	return set_termios(real_tty, p, TERMIOS_WAIT \| TERMIOS_OLD);
966	case TCSETS:	972	case TCSETS:
967	return set_termios(real_tty, p, TERMIOS_OLD);	973	return set_termios(real_tty, p, TERMIOS_OLD);
968	#ifndef TCGETS2	974	#ifndef TCGETS2
969	case TCGETS:	975	case TCGETS:
970	copy_termios(real_tty, &kterm);	976	copy_termios(real_tty, &kterm);
971	if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))	977	if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
972	ret = -EFAULT;	978	ret = -EFAULT;
973	return ret;	979	return ret;
974	#else	980	#else
975	case TCGETS:	981	case TCGETS:
976	copy_termios(real_tty, &kterm);	982	copy_termios(real_tty, &kterm);
977	if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))	983	if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
978	ret = -EFAULT;	984	ret = -EFAULT;
979	return ret;	985	return ret;
980	case TCGETS2:	986	case TCGETS2:
981	copy_termios(real_tty, &kterm);	987	copy_termios(real_tty, &kterm);
982	if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))	988	if (kernel_termios_to_user_termios((struct termios2 __user *)arg, &kterm))
983	ret = -EFAULT;	989	ret = -EFAULT;
984	return ret;	990	return ret;
985	case TCSETSF2:	991	case TCSETSF2:
986	return set_termios(real_tty, p, TERMIOS_FLUSH \| TERMIOS_WAIT);	992	return set_termios(real_tty, p, TERMIOS_FLUSH \| TERMIOS_WAIT);
987	case TCSETSW2:	993	case TCSETSW2:
988	return set_termios(real_tty, p, TERMIOS_WAIT);	994	return set_termios(real_tty, p, TERMIOS_WAIT);
989	case TCSETS2:	995	case TCSETS2:
990	return set_termios(real_tty, p, 0);	996	return set_termios(real_tty, p, 0);
991	#endif	997	#endif
992	case TCGETA:	998	case TCGETA:
993	return get_termio(real_tty, p);	999	return get_termio(real_tty, p);
994	case TCSETAF:	1000	case TCSETAF:
995	return set_termios(real_tty, p, TERMIOS_FLUSH \| TERMIOS_WAIT \| TERMIOS_TERMIO);	1001	return set_termios(real_tty, p, TERMIOS_FLUSH \| TERMIOS_WAIT \| TERMIOS_TERMIO);
996	case TCSETAW:	1002	case TCSETAW:
997	return set_termios(real_tty, p, TERMIOS_WAIT \| TERMIOS_TERMIO);	1003	return set_termios(real_tty, p, TERMIOS_WAIT \| TERMIOS_TERMIO);
998	case TCSETA:	1004	case TCSETA:
999	return set_termios(real_tty, p, TERMIOS_TERMIO);	1005	return set_termios(real_tty, p, TERMIOS_TERMIO);
1000	#ifndef TCGETS2	1006	#ifndef TCGETS2
1001	case TIOCGLCKTRMIOS:	1007	case TIOCGLCKTRMIOS:
1002	copy_termios_locked(real_tty, &kterm);	1008	copy_termios_locked(real_tty, &kterm);
1003	if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))	1009	if (kernel_termios_to_user_termios((struct termios __user *)arg, &kterm))
1004	ret = -EFAULT;	1010	ret = -EFAULT;
1005	return ret;	1011	return ret;
1006	case TIOCSLCKTRMIOS:	1012	case TIOCSLCKTRMIOS:
1007	if (!capable(CAP_SYS_ADMIN))	1013	if (!capable(CAP_SYS_ADMIN))
1008	return -EPERM;	1014	return -EPERM;
1009	copy_termios_locked(real_tty, &kterm);	1015	copy_termios_locked(real_tty, &kterm);
1010	if (user_termios_to_kernel_termios(&kterm,	1016	if (user_termios_to_kernel_termios(&kterm,
1011	(struct termios __user *) arg))	1017	(struct termios __user *) arg))
1012	return -EFAULT;	1018	return -EFAULT;
1013	down_write(&real_tty->termios_rwsem);	1019	down_write(&real_tty->termios_rwsem);
1014	real_tty->termios_locked = kterm;	1020	real_tty->termios_locked = kterm;
1015	up_write(&real_tty->termios_rwsem);	1021	up_write(&real_tty->termios_rwsem);
1016	return 0;	1022	return 0;
1017	#else	1023	#else
1018	case TIOCGLCKTRMIOS:	1024	case TIOCGLCKTRMIOS:
1019	copy_termios_locked(real_tty, &kterm);	1025	copy_termios_locked(real_tty, &kterm);
1020	if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))	1026	if (kernel_termios_to_user_termios_1((struct termios __user *)arg, &kterm))
1021	ret = -EFAULT;	1027	ret = -EFAULT;
1022	return ret;	1028	return ret;
1023	case TIOCSLCKTRMIOS:	1029	case TIOCSLCKTRMIOS:
1024	if (!capable(CAP_SYS_ADMIN))	1030	if (!capable(CAP_SYS_ADMIN))
1025	return -EPERM;	1031	return -EPERM;
1026	copy_termios_locked(real_tty, &kterm);	1032	copy_termios_locked(real_tty, &kterm);
1027	if (user_termios_to_kernel_termios_1(&kterm,	1033	if (user_termios_to_kernel_termios_1(&kterm,
1028	(struct termios __user *) arg))	1034	(struct termios __user *) arg))
1029	return -EFAULT;	1035	return -EFAULT;
1030	down_write(&real_tty->termios_rwsem);	1036	down_write(&real_tty->termios_rwsem);
1031	real_tty->termios_locked = kterm;	1037	real_tty->termios_locked = kterm;
1032	up_write(&real_tty->termios_rwsem);	1038	up_write(&real_tty->termios_rwsem);
1033	return ret;	1039	return ret;
1034	#endif	1040	#endif
1035	#ifdef TCGETX	1041	#ifdef TCGETX
1036	case TCGETX: {	1042	case TCGETX: {
1037	struct termiox ktermx;	1043	struct termiox ktermx;
1038	if (real_tty->termiox == NULL)	1044	if (real_tty->termiox == NULL)
1039	return -EINVAL;	1045	return -EINVAL;
1040	down_read(&real_tty->termios_rwsem);	1046	down_read(&real_tty->termios_rwsem);
1041	memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));	1047	memcpy(&ktermx, real_tty->termiox, sizeof(struct termiox));
1042	up_read(&real_tty->termios_rwsem);	1048	up_read(&real_tty->termios_rwsem);
1043	if (copy_to_user(p, &ktermx, sizeof(struct termiox)))	1049	if (copy_to_user(p, &ktermx, sizeof(struct termiox)))
1044	ret = -EFAULT;	1050	ret = -EFAULT;
1045	return ret;	1051	return ret;
1046	}	1052	}
1047	case TCSETX:	1053	case TCSETX:
1048	return set_termiox(real_tty, p, 0);	1054	return set_termiox(real_tty, p, 0);
1049	case TCSETXW:	1055	case TCSETXW:
1050	return set_termiox(real_tty, p, TERMIOS_WAIT);	1056	return set_termiox(real_tty, p, TERMIOS_WAIT);
1051	case TCSETXF:	1057	case TCSETXF:
1052	return set_termiox(real_tty, p, TERMIOS_FLUSH);	1058	return set_termiox(real_tty, p, TERMIOS_FLUSH);
1053	#endif	1059	#endif
1054	case TIOCGSOFTCAR:	1060	case TIOCGSOFTCAR:
1055	copy_termios(real_tty, &kterm);	1061	copy_termios(real_tty, &kterm);
1056	ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,	1062	ret = put_user((kterm.c_cflag & CLOCAL) ? 1 : 0,
1057	(int __user *)arg);	1063	(int __user *)arg);
1058	return ret;	1064	return ret;
1059	case TIOCSSOFTCAR:	1065	case TIOCSSOFTCAR:
1060	if (get_user(arg, (unsigned int __user *) arg))	1066	if (get_user(arg, (unsigned int __user *) arg))
1061	return -EFAULT;	1067	return -EFAULT;
1062	return tty_change_softcar(real_tty, arg);	1068	return tty_change_softcar(real_tty, arg);
1063	default:	1069	default:
1064	return -ENOIOCTLCMD;	1070	return -ENOIOCTLCMD;
1065	}	1071	}
1066	}	1072	}
1067	EXPORT_SYMBOL_GPL(tty_mode_ioctl);	1073	EXPORT_SYMBOL_GPL(tty_mode_ioctl);
1068		1074
1069		1075
1070	/* Caller guarantees ldisc reference is held */	1076	/* Caller guarantees ldisc reference is held */
1071	static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)	1077	static int __tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1072	{	1078	{
1073	struct tty_ldisc *ld = tty->ldisc;	1079	struct tty_ldisc *ld = tty->ldisc;
1074		1080
1075	switch (arg) {	1081	switch (arg) {
1076	case TCIFLUSH:	1082	case TCIFLUSH:
1077	if (ld && ld->ops->flush_buffer) {	1083	if (ld && ld->ops->flush_buffer) {
1078	ld->ops->flush_buffer(tty);	1084	ld->ops->flush_buffer(tty);
1079	tty_unthrottle(tty);	1085	tty_unthrottle(tty);
1080	}	1086	}
1081	break;	1087	break;
1082	case TCIOFLUSH:	1088	case TCIOFLUSH:
1083	if (ld && ld->ops->flush_buffer) {	1089	if (ld && ld->ops->flush_buffer) {
1084	ld->ops->flush_buffer(tty);	1090	ld->ops->flush_buffer(tty);
1085	tty_unthrottle(tty);	1091	tty_unthrottle(tty);
1086	}	1092	}
1087	/* fall through */	1093	/* fall through */
1088	case TCOFLUSH:	1094	case TCOFLUSH:
1089	tty_driver_flush_buffer(tty);	1095	tty_driver_flush_buffer(tty);
1090	break;	1096	break;
1091	default:	1097	default:
1092	return -EINVAL;	1098	return -EINVAL;
1093	}	1099	}
1094	return 0;	1100	return 0;
1095	}	1101	}
1096		1102
1097	int tty_perform_flush(struct tty_struct *tty, unsigned long arg)	1103	int tty_perform_flush(struct tty_struct *tty, unsigned long arg)
1098	{	1104	{
1099	struct tty_ldisc *ld;	1105	struct tty_ldisc *ld;
1100	int retval = tty_check_change(tty);	1106	int retval = tty_check_change(tty);
1101	if (retval)	1107	if (retval)
1102	return retval;	1108	return retval;
1103		1109
1104	ld = tty_ldisc_ref_wait(tty);	1110	ld = tty_ldisc_ref_wait(tty);
1105	retval = __tty_perform_flush(tty, arg);	1111	retval = __tty_perform_flush(tty, arg);
1106	if (ld)	1112	if (ld)
1107	tty_ldisc_deref(ld);	1113	tty_ldisc_deref(ld);
1108	return retval;	1114	return retval;
1109	}	1115	}
1110	EXPORT_SYMBOL_GPL(tty_perform_flush);	1116	EXPORT_SYMBOL_GPL(tty_perform_flush);
1111		1117
1112	int n_tty_ioctl_helper(struct tty_struct tty, struct file file,	1118	int n_tty_ioctl_helper(struct tty_struct tty, struct file file,
1113	unsigned int cmd, unsigned long arg)	1119	unsigned int cmd, unsigned long arg)
1114	{	1120	{
1115	int retval;	1121	int retval;
1116		1122
1117	switch (cmd) {	1123	switch (cmd) {
1118	case TCXONC:	1124	case TCXONC:
1119	retval = tty_check_change(tty);	1125	retval = tty_check_change(tty);
1120	if (retval)	1126	if (retval)
1121	return retval;	1127	return retval;
1122	switch (arg) {	1128	switch (arg) {
1123	case TCOOFF:	1129	case TCOOFF:
1124	spin_lock_irq(&tty->flow_lock);	1130	spin_lock_irq(&tty->flow_lock);
1125	if (!tty->flow_stopped) {	1131	if (!tty->flow_stopped) {
1126	tty->flow_stopped = 1;	1132	tty->flow_stopped = 1;
1127	__stop_tty(tty);	1133	__stop_tty(tty);
1128	}	1134	}
1129	spin_unlock_irq(&tty->flow_lock);	1135	spin_unlock_irq(&tty->flow_lock);
1130	break;	1136	break;
1131	case TCOON:	1137	case TCOON:
1132	spin_lock_irq(&tty->flow_lock);	1138	spin_lock_irq(&tty->flow_lock);
1133	if (tty->flow_stopped) {	1139	if (tty->flow_stopped) {
1134	tty->flow_stopped = 0;	1140	tty->flow_stopped = 0;
1135	__start_tty(tty);	1141	__start_tty(tty);
1136	}	1142	}
1137	spin_unlock_irq(&tty->flow_lock);	1143	spin_unlock_irq(&tty->flow_lock);
1138	break;	1144	break;
1139	case TCIOFF:	1145	case TCIOFF:
1140	down_read(&tty->termios_rwsem);	1146	down_read(&tty->termios_rwsem);
1141	if (STOP_CHAR(tty) != __DISABLED_CHAR)	1147	if (STOP_CHAR(tty) != __DISABLED_CHAR)
1142	retval = tty_send_xchar(tty, STOP_CHAR(tty));	1148	retval = tty_send_xchar(tty, STOP_CHAR(tty));
1143	up_read(&tty->termios_rwsem);	1149	up_read(&tty->termios_rwsem);
1144	break;	1150	break;
1145	case TCION:	1151	case TCION:
1146	down_read(&tty->termios_rwsem);	1152	down_read(&tty->termios_rwsem);
1147	if (START_CHAR(tty) != __DISABLED_CHAR)	1153	if (START_CHAR(tty) != __DISABLED_CHAR)
1148	retval = tty_send_xchar(tty, START_CHAR(tty));	1154	retval = tty_send_xchar(tty, START_CHAR(tty));
1149	up_read(&tty->termios_rwsem);	1155	up_read(&tty->termios_rwsem);
1150	break;	1156	break;
1151	default:	1157	default:
1152	return -EINVAL;	1158	return -EINVAL;
1153	}	1159	}
1154	return retval;	1160	return retval;
1155	case TCFLSH:	1161	case TCFLSH:
1156	retval = tty_check_change(tty);	1162	retval = tty_check_change(tty);
1157	if (retval)	1163	if (retval)
1158	return retval;	1164	return retval;
1159	return __tty_perform_flush(tty, arg);	1165	return __tty_perform_flush(tty, arg);
1160	default:	1166	default:
1161	/* Try the mode commands */	1167	/* Try the mode commands */
1162	return tty_mode_ioctl(tty, file, cmd, arg);	1168	return tty_mode_ioctl(tty, file, cmd, arg);
1163	}	1169	}
1164	}	1170	}
1165	EXPORT_SYMBOL(n_tty_ioctl_helper);	1171	EXPORT_SYMBOL(n_tty_ioctl_helper);
1166		1172
1167	#ifdef CONFIG_COMPAT	1173	#ifdef CONFIG_COMPAT
1168	long n_tty_compat_ioctl_helper(struct tty_struct tty, struct file file,	1174	long n_tty_compat_ioctl_helper(struct tty_struct tty, struct file file,
1169	unsigned int cmd, unsigned long arg)	1175	unsigned int cmd, unsigned long arg)
1170	{	1176	{
1171	switch (cmd) {	1177	switch (cmd) {
1172	case TIOCGLCKTRMIOS:	1178	case TIOCGLCKTRMIOS:
1173	case TIOCSLCKTRMIOS:	1179	case TIOCSLCKTRMIOS:
1174	return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));	1180	return tty_mode_ioctl(tty, file, cmd, (unsigned long) compat_ptr(arg));
1175	default:	1181	default:
1176	return -ENOIOCTLCMD;	1182	return -ENOIOCTLCMD;
1177	}	1183	}
1178	}	1184	}
1179	EXPORT_SYMBOL(n_tty_compat_ioctl_helper);	1185	EXPORT_SYMBOL(n_tty_compat_ioctl_helper);
1180	#endif	1186	#endif
1181		1187
1182		1188

drivers/usb/serial/generic.c

Diff comments View file @ bbbce51

 /*
  * USB Serial Converter Generic functions
  *
  * Copyright (C) 2010 - 2013 Johan Hovold (jhovold@gmail.com)
  * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
  *
  *	This program is free software; you can redistribute it and/or
  *	modify it under the terms of the GNU General Public License version
  *	2 as published by the Free Software Foundation.
  */
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/sysrq.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 #include <linux/uaccess.h>
 #include <linux/kfifo.h>
 #include <linux/serial.h>
 #ifdef CONFIG_USB_SERIAL_GENERIC
 static __u16 vendor  = 0x05f9;
 static __u16 product = 0xffff;
 module_param(vendor, ushort, 0);
 MODULE_PARM_DESC(vendor, "User specified USB idVendor");
 module_param(product, ushort, 0);
 MODULE_PARM_DESC(product, "User specified USB idProduct");
 static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */
 struct usb_serial_driver usb_serial_generic_device = {
 	.driver = {
 		.owner =	THIS_MODULE,
 		.name =		"generic",
 	},
 	.id_table =		generic_device_ids,
 	.num_ports =		1,
 	.throttle =		usb_serial_generic_throttle,
 	.unthrottle =		usb_serial_generic_unthrottle,
 	.resume =		usb_serial_generic_resume,
 };
 static struct usb_serial_driver * const serial_drivers[] = {
 	&usb_serial_generic_device, NULL
 };
 #endif
 int usb_serial_generic_register(void)
 {
 	int retval = 0;
 #ifdef CONFIG_USB_SERIAL_GENERIC
 	generic_device_ids[0].idVendor = vendor;
 	generic_device_ids[0].idProduct = product;
 	generic_device_ids[0].match_flags =
 		USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT;
 	retval = usb_serial_register_drivers(serial_drivers,
 			"usbserial_generic", generic_device_ids);
 #endif
 	return retval;
 }
 void usb_serial_generic_deregister(void)
 {
 #ifdef CONFIG_USB_SERIAL_GENERIC
 	usb_serial_deregister_drivers(serial_drivers);
 #endif
 }
 int usb_serial_generic_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
 	int result = 0;
 	unsigned long flags;
 	spin_lock_irqsave(&port->lock, flags);
 	port->throttled = 0;
 	port->throttle_req = 0;
 	spin_unlock_irqrestore(&port->lock, flags);
 	if (port->bulk_in_size)
 		result = usb_serial_generic_submit_read_urbs(port, GFP_KERNEL);
 	return result;
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_open);
 void usb_serial_generic_close(struct usb_serial_port *port)
 {
 	unsigned long flags;
 	int i;
 	if (port->bulk_out_size) {
 		for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
 			usb_kill_urb(port->write_urbs[i]);
 		spin_lock_irqsave(&port->lock, flags);
 		kfifo_reset_out(&port->write_fifo);
 		spin_unlock_irqrestore(&port->lock, flags);
 	}
 	if (port->bulk_in_size) {
 		for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
 			usb_kill_urb(port->read_urbs[i]);
 	}
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_close);
 int usb_serial_generic_prepare_write_buffer(struct usb_serial_port *port,
 						void *dest, size_t size)
 {
 	return kfifo_out_locked(&port->write_fifo, dest, size, &port->lock);
 }
 /**
  * usb_serial_generic_write_start - start writing buffered data
  * @port: usb-serial port
  * @mem_flags: flags to use for memory allocations
  *
  * Serialised using USB_SERIAL_WRITE_BUSY flag.
  *
  * Return: Zero on success or if busy, otherwise a negative errno value.
  */
 int usb_serial_generic_write_start(struct usb_serial_port *port,
 							gfp_t mem_flags)
 {
 	struct urb *urb;
 	int count, result;
 	unsigned long flags;
 	int i;
 	if (test_and_set_bit_lock(USB_SERIAL_WRITE_BUSY, &port->flags))
 		return 0;
 retry:
 	spin_lock_irqsave(&port->lock, flags);
 	if (!port->write_urbs_free || !kfifo_len(&port->write_fifo)) {
 		clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
 		spin_unlock_irqrestore(&port->lock, flags);
 		return 0;
 	}
 	i = (int)find_first_bit(&port->write_urbs_free,
 						ARRAY_SIZE(port->write_urbs));
 	spin_unlock_irqrestore(&port->lock, flags);
 	urb = port->write_urbs[i];
 	count = port->serial->type->prepare_write_buffer(port,
 						urb->transfer_buffer,
 						port->bulk_out_size);
 	urb->transfer_buffer_length = count;
 	usb_serial_debug_data(&port->dev, __func__, count, urb->transfer_buffer);
 	spin_lock_irqsave(&port->lock, flags);
 	port->tx_bytes += count;
 	spin_unlock_irqrestore(&port->lock, flags);
 	clear_bit(i, &port->write_urbs_free);
 	result = usb_submit_urb(urb, mem_flags);
 	if (result) {
 		dev_err_console(port, "%s - error submitting urb: %d\n",
 						__func__, result);
 		set_bit(i, &port->write_urbs_free);
 		spin_lock_irqsave(&port->lock, flags);
 		port->tx_bytes -= count;
 		spin_unlock_irqrestore(&port->lock, flags);
 		clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
 		return result;
 	}
 	goto retry;	/* try sending off another urb */
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_write_start);
 /**
  * usb_serial_generic_write - generic write function
  * @tty: tty for the port
  * @port: usb-serial port
  * @buf: data to write
  * @count: number of bytes to write
  *
  * Return: The number of characters buffered, which may be anything from
  * zero to @count, or a negative errno value.
  */
 int usb_serial_generic_write(struct tty_struct *tty,
 	struct usb_serial_port *port, const unsigned char *buf, int count)
 {
 	int result;
 	if (!port->bulk_out_size)
 		return -ENODEV;
 	if (!count)
 		return 0;
 	count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
 	result = usb_serial_generic_write_start(port, GFP_ATOMIC);
 	if (result)
 		return result;
 	return count;
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_write);
 int usb_serial_generic_write_room(struct tty_struct *tty)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	unsigned long flags;
 	int room;
 	if (!port->bulk_out_size)
 		return 0;
 	spin_lock_irqsave(&port->lock, flags);
 	room = kfifo_avail(&port->write_fifo);
 	spin_unlock_irqrestore(&port->lock, flags);
 	dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
 	return room;
 }
 int usb_serial_generic_chars_in_buffer(struct tty_struct *tty)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	unsigned long flags;
 	int chars;
 	if (!port->bulk_out_size)
 		return 0;
 	spin_lock_irqsave(&port->lock, flags);
 	chars = kfifo_len(&port->write_fifo) + port->tx_bytes;
 	spin_unlock_irqrestore(&port->lock, flags);
 	dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
 	return chars;
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_chars_in_buffer);
 void usb_serial_generic_wait_until_sent(struct tty_struct *tty, long timeout)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	unsigned int bps;
 	unsigned long period;
 	unsigned long expire;
 	bps = tty_get_baud_rate(tty);
 	if (!bps)
 		bps = 9600;	/* B0 */
 	/*
 	 * Use a poll-period of roughly the time it takes to send one
 	 * character or at least one jiffy.
 	 */
 	period = max_t(unsigned long, (10 * HZ / bps), 1);
-	period = min_t(unsigned long, period, timeout);
+	if (timeout)
+		period = min_t(unsigned long, period, timeout);
 	dev_dbg(&port->dev, "%s - timeout = %u ms, period = %u ms\n",
 					__func__, jiffies_to_msecs(timeout),
 					jiffies_to_msecs(period));
 	expire = jiffies + timeout;
 	while (!port->serial->type->tx_empty(port)) {
 		schedule_timeout_interruptible(period);
 		if (signal_pending(current))
 			break;
-		if (time_after(jiffies, expire))
+		if (timeout && time_after(jiffies, expire))
 			break;
 	}
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_wait_until_sent);
 static int usb_serial_generic_submit_read_urb(struct usb_serial_port *port,
 						int index, gfp_t mem_flags)
 {
 	int res;
 	if (!test_and_clear_bit(index, &port->read_urbs_free))
 		return 0;
 	dev_dbg(&port->dev, "%s - urb %d\n", __func__, index);
 	res = usb_submit_urb(port->read_urbs[index], mem_flags);
 	if (res) {
 		if (res != -EPERM && res != -ENODEV) {
 			dev_err(&port->dev,
 					"%s - usb_submit_urb failed: %d\n",
 					__func__, res);
 		}
 		set_bit(index, &port->read_urbs_free);
 		return res;
 	}
 	return 0;
 }
 int usb_serial_generic_submit_read_urbs(struct usb_serial_port *port,
 					gfp_t mem_flags)
 {
 	int res;
 	int i;
 	for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
 		res = usb_serial_generic_submit_read_urb(port, i, mem_flags);
 		if (res)
 			goto err;
 	}
 	return 0;
 err:
 	for (; i >= 0; --i)
 		usb_kill_urb(port->read_urbs[i]);
 	return res;
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_submit_read_urbs);
 void usb_serial_generic_process_read_urb(struct urb *urb)
 {
 	struct usb_serial_port *port = urb->context;
 	char *ch = (char *)urb->transfer_buffer;
 	int i;
 	if (!urb->actual_length)
 		return;
 	/*
 	 * The per character mucking around with sysrq path it too slow for
 	 * stuff like 3G modems, so shortcircuit it in the 99.9999999% of
 	 * cases where the USB serial is not a console anyway.
 	 */
 	if (!port->port.console || !port->sysrq) {
 		tty_insert_flip_string(&port->port, ch, urb->actual_length);
 	} else {
 		for (i = 0; i < urb->actual_length; i++, ch++) {
 			if (!usb_serial_handle_sysrq_char(port, *ch))
 				tty_insert_flip_char(&port->port, *ch, TTY_NORMAL);
 		}
 	}
 	tty_flip_buffer_push(&port->port);
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_process_read_urb);
 void usb_serial_generic_read_bulk_callback(struct urb *urb)
 {
 	struct usb_serial_port *port = urb->context;
 	unsigned char *data = urb->transfer_buffer;
 	unsigned long flags;
 	int i;
 	for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
 		if (urb == port->read_urbs[i])
 			break;
 	}
 	set_bit(i, &port->read_urbs_free);
 	dev_dbg(&port->dev, "%s - urb %d, len %d\n", __func__, i,
 							urb->actual_length);
 	switch (urb->status) {
 	case 0:
 		break;
 	case -ENOENT:
 	case -ECONNRESET:
 	case -ESHUTDOWN:
 		dev_dbg(&port->dev, "%s - urb stopped: %d\n",
 							__func__, urb->status);
 		return;
 	case -EPIPE:
 		dev_err(&port->dev, "%s - urb stopped: %d\n",
 							__func__, urb->status);
 		return;
 	default:
 		dev_dbg(&port->dev, "%s - nonzero urb status: %d\n",
 							__func__, urb->status);
 		goto resubmit;
 	}
 	usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 	port->serial->type->process_read_urb(urb);
 resubmit:
 	/* Throttle the device if requested by tty */
 	spin_lock_irqsave(&port->lock, flags);
 	port->throttled = port->throttle_req;
 	if (!port->throttled) {
 		spin_unlock_irqrestore(&port->lock, flags);
 		usb_serial_generic_submit_read_urb(port, i, GFP_ATOMIC);
 	} else {
 		spin_unlock_irqrestore(&port->lock, flags);
 	}
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_read_bulk_callback);
 void usb_serial_generic_write_bulk_callback(struct urb *urb)
 {
 	unsigned long flags;
 	struct usb_serial_port *port = urb->context;
 	int i;
 	for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
 		if (port->write_urbs[i] == urb)
 			break;
 	}
 	spin_lock_irqsave(&port->lock, flags);
 	port->tx_bytes -= urb->transfer_buffer_length;
 	set_bit(i, &port->write_urbs_free);
 	spin_unlock_irqrestore(&port->lock, flags);
 	switch (urb->status) {
 	case 0:
 		break;
 	case -ENOENT:
 	case -ECONNRESET:
 	case -ESHUTDOWN:
 		dev_dbg(&port->dev, "%s - urb stopped: %d\n",
 							__func__, urb->status);
 		return;
 	case -EPIPE:
 		dev_err_console(port, "%s - urb stopped: %d\n",
 							__func__, urb->status);
 		return;
 	default:
 		dev_err_console(port, "%s - nonzero urb status: %d\n",
 							__func__, urb->status);
 		goto resubmit;
 	}
 resubmit:
 	usb_serial_generic_write_start(port, GFP_ATOMIC);
 	usb_serial_port_softint(port);
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback);
 void usb_serial_generic_throttle(struct tty_struct *tty)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	unsigned long flags;
 	spin_lock_irqsave(&port->lock, flags);
 	port->throttle_req = 1;
 	spin_unlock_irqrestore(&port->lock, flags);
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_throttle);
 void usb_serial_generic_unthrottle(struct tty_struct *tty)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	int was_throttled;
 	spin_lock_irq(&port->lock);
 	was_throttled = port->throttled;
 	port->throttled = port->throttle_req = 0;
 	spin_unlock_irq(&port->lock);
 	if (was_throttled)
 		usb_serial_generic_submit_read_urbs(port, GFP_KERNEL);
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_unthrottle);
 static bool usb_serial_generic_msr_changed(struct tty_struct *tty,
 				unsigned long arg, struct async_icount *cprev)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	struct async_icount cnow;
 	unsigned long flags;
 	bool ret;
 	/*
 	 * Use tty-port initialised flag to detect all hangups including the
 	 * one generated at USB-device disconnect.
 	 */
 	if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
 		return true;
 	spin_lock_irqsave(&port->lock, flags);
 	cnow = port->icount;				/* atomic copy*/
 	spin_unlock_irqrestore(&port->lock, flags);
 	ret =	((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));
 	*cprev = cnow;
 	return ret;
 }
 int usb_serial_generic_tiocmiwait(struct tty_struct *tty, unsigned long arg)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	struct async_icount cnow;
 	unsigned long flags;
 	int ret;
 	spin_lock_irqsave(&port->lock, flags);
 	cnow = port->icount;				/* atomic copy */
 	spin_unlock_irqrestore(&port->lock, flags);
 	ret = wait_event_interruptible(port->port.delta_msr_wait,
 			usb_serial_generic_msr_changed(tty, arg, &cnow));
 	if (!ret && !test_bit(ASYNCB_INITIALIZED, &port->port.flags))
 		ret = -EIO;
 	return ret;
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_tiocmiwait);
 int usb_serial_generic_get_icount(struct tty_struct *tty,
 					struct serial_icounter_struct *icount)
 {
 	struct usb_serial_port *port = tty->driver_data;
 	struct async_icount cnow;
 	unsigned long flags;
 	spin_lock_irqsave(&port->lock, flags);
 	cnow = port->icount;				/* atomic copy */
 	spin_unlock_irqrestore(&port->lock, flags);
 	icount->cts = cnow.cts;
 	icount->dsr = cnow.dsr;
 	icount->rng = cnow.rng;
 	icount->dcd = cnow.dcd;
 	icount->tx = cnow.tx;
 	icount->rx = cnow.rx;
 	icount->frame = cnow.frame;
 	icount->parity = cnow.parity;
 	icount->overrun = cnow.overrun;
 	icount->brk = cnow.brk;
 	icount->buf_overrun = cnow.buf_overrun;
 	return 0;
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_get_icount);
 #ifdef CONFIG_MAGIC_SYSRQ
 int usb_serial_handle_sysrq_char(struct usb_serial_port *port, unsigned int ch)
 {
 	if (port->sysrq && port->port.console) {
 		if (ch && time_before(jiffies, port->sysrq)) {
 			handle_sysrq(ch);
 			port->sysrq = 0;
 			return 1;
 		}
 		port->sysrq = 0;
 	}
 	return 0;
 }
 #else
 int usb_serial_handle_sysrq_char(struct usb_serial_port *port, unsigned int ch)
 {
 	return 0;
 }
 #endif
 EXPORT_SYMBOL_GPL(usb_serial_handle_sysrq_char);
 int usb_serial_handle_break(struct usb_serial_port *port)
 {
 	if (!port->sysrq) {
 		port->sysrq = jiffies + HZ*5;
 		return 1;
 	}
 	port->sysrq = 0;
 	return 0;
 }
 EXPORT_SYMBOL_GPL(usb_serial_handle_break);
 /**
  * usb_serial_handle_dcd_change - handle a change of carrier detect state
  * @port: usb-serial port
  * @tty: tty for the port
  * @status: new carrier detect status, nonzero if active
  */
 void usb_serial_handle_dcd_change(struct usb_serial_port *usb_port,
 				struct tty_struct *tty, unsigned int status)
 {
 	struct tty_port *port = &usb_port->port;
 	dev_dbg(&usb_port->dev, "%s - status %d\n", __func__, status);
 	if (tty) {
 		struct tty_ldisc *ld = tty_ldisc_ref(tty);
 		if (ld) {
 			if (ld->ops->dcd_change)
 				ld->ops->dcd_change(tty, status);
 			tty_ldisc_deref(ld);
 		}
 	}
 	if (status)
 		wake_up_interruptible(&port->open_wait);
 	else if (tty && !C_CLOCAL(tty))
 		tty_hangup(tty);
 }
 EXPORT_SYMBOL_GPL(usb_serial_handle_dcd_change);
 int usb_serial_generic_resume(struct usb_serial *serial)
 {
 	struct usb_serial_port *port;
 	int i, c = 0, r;
 	for (i = 0; i < serial->num_ports; i++) {
 		port = serial->port[i];
 		if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
 			continue;
 		if (port->bulk_in_size) {
 			r = usb_serial_generic_submit_read_urbs(port,
 								GFP_NOIO);
 			if (r < 0)
 				c++;
 		}
 		if (port->bulk_out_size) {
 			r = usb_serial_generic_write_start(port, GFP_NOIO);
 			if (r < 0)
 				c++;
 		}
 	}
 	return c ? -EIO : 0;
 }
 EXPORT_SYMBOL_GPL(usb_serial_generic_resume);

include/linux/serial_core.h

Diff comments View file @ bbbce51

include/uapi/linux/serial.h

Diff comments View file @ bbbce51

 /*
  * include/linux/serial.h
  *
  * Copyright (C) 1992 by Theodore Ts'o.
  *
  * Redistribution of this file is permitted under the terms of the GNU
  * Public License (GPL)
  */
 #ifndef _UAPI_LINUX_SERIAL_H
 #define _UAPI_LINUX_SERIAL_H
 #include <linux/types.h>
 #include <linux/tty_flags.h>
 struct serial_struct {
 	int	type;
 	int	line;
 	unsigned int	port;
 	int	irq;
 	int	flags;
 	int	xmit_fifo_size;
 	int	custom_divisor;
 	int	baud_base;
 	unsigned short	close_delay;
 	char	io_type;
 	char	reserved_char[1];
 	int	hub6;
 	unsigned short	closing_wait; /* time to wait before closing */
 	unsigned short	closing_wait2; /* no longer used... */
 	unsigned char	*iomem_base;
 	unsigned short	iomem_reg_shift;
 	unsigned int	port_high;
 	unsigned long	iomap_base;	/* cookie passed into ioremap */
 };
 /*
  * For the close wait times, 0 means wait forever for serial port to
  * flush its output.  65535 means don't wait at all.
  */
 #define ASYNC_CLOSING_WAIT_INF	0
 #define ASYNC_CLOSING_WAIT_NONE	65535
 /*
  * These are the supported serial types.
  */
 #define PORT_UNKNOWN	0
 #define PORT_8250	1
 #define PORT_16450	2
 #define PORT_16550	3
 #define PORT_16550A	4
 #define PORT_CIRRUS     5	/* usurped by cyclades.c */
 #define PORT_16650	6
 #define PORT_16650V2	7
 #define PORT_16750	8
 #define PORT_STARTECH	9	/* usurped by cyclades.c */
 #define PORT_16C950	10	/* Oxford Semiconductor */
 #define PORT_16654	11
 #define PORT_16850	12
 #define PORT_RSA	13	/* RSA-DV II/S card */
 #define PORT_MAX	13
 #define SERIAL_IO_PORT	0
 #define SERIAL_IO_HUB6	1
 #define SERIAL_IO_MEM	2
+#define SERIAL_IO_MEM32	  3
+#define SERIAL_IO_AU	  4
+#define SERIAL_IO_TSI	  5
+#define SERIAL_IO_MEM32BE 6
 #define UART_CLEAR_FIFO		0x01
 #define UART_USE_FIFO		0x02
 #define UART_STARTECH		0x04
 #define UART_NATSEMI		0x08
 /*
  * Multiport serial configuration structure --- external structure
  */
 struct serial_multiport_struct {
 	int		irq;
 	int		port1;
 	unsigned char	mask1, match1;
 	int		port2;
 	unsigned char	mask2, match2;
 	int		port3;
 	unsigned char	mask3, match3;
 	int		port4;
 	unsigned char	mask4, match4;
 	int		port_monitor;
 	int	reserved[32];
 };
 /*
  * Serial input interrupt line counters -- external structure
  * Four lines can interrupt: CTS, DSR, RI, DCD
  */
 struct serial_icounter_struct {
 	int cts, dsr, rng, dcd;
 	int rx, tx;
 	int frame, overrun, parity, brk;
 	int buf_overrun;
 	int reserved[9];
 };
 /*
  * Serial interface for controlling RS485 settings on chips with suitable
  * support. Set with TIOCSRS485 and get with TIOCGRS485 if supported by your
  * platform. The set function returns the new state, with any unsupported bits
  * reverted appropriately.
  */
 struct serial_rs485 {
 	__u32	flags;			/* RS485 feature flags */
 #define SER_RS485_ENABLED		(1 << 0)	/* If enabled */
 #define SER_RS485_RTS_ON_SEND		(1 << 1)	/* Logical level for
 							   RTS pin when
 							   sending */
 #define SER_RS485_RTS_AFTER_SEND	(1 << 2)	/* Logical level for
 							   RTS pin after sent*/
 #define SER_RS485_RX_DURING_TX		(1 << 4)
 	__u32	delay_rts_before_send;	/* Delay before send (milliseconds) */
 	__u32	delay_rts_after_send;	/* Delay after send (milliseconds) */
 	__u32	padding[5];		/* Memory is cheap, new structs
 					   are a royal PITA .. */
 };
 #endif /* _UAPI_LINUX_SERIAL_H */

kernel/printk/console_cmdline.h

Diff comments View file @ bbbce51

1	#ifndef _CONSOLE_CMDLINE_H	1	#ifndef _CONSOLE_CMDLINE_H
2	#define _CONSOLE_CMDLINE_H	2	#define _CONSOLE_CMDLINE_H
3		3
4	struct console_cmdline	4	struct console_cmdline
5	{	5	{
6	char name[8]; /* Name of the driver */	6	char name[16]; /* Name of the driver */
7	int index; /* Minor dev. to use */	7	int index; /* Minor dev. to use */
8	char options; / Options for the driver */	8	char options; / Options for the driver */
9	#ifdef CONFIG_A11Y_BRAILLE_CONSOLE	9	#ifdef CONFIG_A11Y_BRAILLE_CONSOLE
10	char brl_options; / Options for braille driver */	10	char brl_options; / Options for braille driver */
11	#endif	11	#endif
12	};	12	};
13		13
14	#endif	14	#endif
15		15

kernel/printk/printk.c

Diff comments View file @ bbbce51

 /*
  *  linux/kernel/printk.c
  *
  *  Copyright (C) 1991, 1992  Linus Torvalds
  *
  * Modified to make sys_syslog() more flexible: added commands to
  * return the last 4k of kernel messages, regardless of whether
  * they've been read or not.  Added option to suppress kernel printk's
  * to the console.  Added hook for sending the console messages
  * elsewhere, in preparation for a serial line console (someday).
  * Ted Ts'o, 2/11/93.
  * Modified for sysctl support, 1/8/97, Chris Horn.
  * Fixed SMP synchronization, 08/08/99, Manfred Spraul
  *     manfred@colorfullife.com
  * Rewrote bits to get rid of console_lock
  *	01Mar01 Andrew Morton
  */
 #include <linux/kernel.h>
 #include <linux/mm.h>
 #include <linux/tty.h>
 #include <linux/tty_driver.h>
 #include <linux/console.h>
 #include <linux/init.h>
 #include <linux/jiffies.h>
 #include <linux/nmi.h>
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/interrupt.h>			/* For in_interrupt() */
 #include <linux/delay.h>
 #include <linux/smp.h>
 #include <linux/security.h>
 #include <linux/bootmem.h>
 #include <linux/memblock.h>
 #include <linux/aio.h>
 #include <linux/syscalls.h>
 #include <linux/kexec.h>
 #include <linux/kdb.h>
 #include <linux/ratelimit.h>
 #include <linux/kmsg_dump.h>
 #include <linux/syslog.h>
 #include <linux/cpu.h>
 #include <linux/notifier.h>
 #include <linux/rculist.h>
 #include <linux/poll.h>
 #include <linux/irq_work.h>
 #include <linux/utsname.h>
 #include <linux/ctype.h>
 #include <asm/uaccess.h>
 #define CREATE_TRACE_POINTS
 #include <trace/events/printk.h>
 #include "console_cmdline.h"
 #include "braille.h"
 int console_printk[4] = {
 	CONSOLE_LOGLEVEL_DEFAULT,	/* console_loglevel */
 	MESSAGE_LOGLEVEL_DEFAULT,	/* default_message_loglevel */
 	CONSOLE_LOGLEVEL_MIN,		/* minimum_console_loglevel */
 	CONSOLE_LOGLEVEL_DEFAULT,	/* default_console_loglevel */
 };
 /*
  * Low level drivers may need that to know if they can schedule in
  * their unblank() callback or not. So let's export it.
  */
 int oops_in_progress;
 EXPORT_SYMBOL(oops_in_progress);
 /*
  * console_sem protects the console_drivers list, and also
  * provides serialisation for access to the entire console
  * driver system.
  */
 static DEFINE_SEMAPHORE(console_sem);
 struct console *console_drivers;
 EXPORT_SYMBOL_GPL(console_drivers);
 #ifdef CONFIG_LOCKDEP
 static struct lockdep_map console_lock_dep_map = {
 	.name = "console_lock"
 };
 #endif
 /*
  * Helper macros to handle lockdep when locking/unlocking console_sem. We use
  * macros instead of functions so that _RET_IP_ contains useful information.
  */
 #define down_console_sem() do { \
 	down(&console_sem);\
 	mutex_acquire(&console_lock_dep_map, 0, 0, _RET_IP_);\
 } while (0)
 static int __down_trylock_console_sem(unsigned long ip)
 {
 	if (down_trylock(&console_sem))
 		return 1;
 	mutex_acquire(&console_lock_dep_map, 0, 1, ip);
 	return 0;
 }
 #define down_trylock_console_sem() __down_trylock_console_sem(_RET_IP_)
 #define up_console_sem() do { \
 	mutex_release(&console_lock_dep_map, 1, _RET_IP_);\
 	up(&console_sem);\
 } while (0)
 /*
  * This is used for debugging the mess that is the VT code by
  * keeping track if we have the console semaphore held. It's
  * definitely not the perfect debug tool (we don't know if _WE_
  * hold it and are racing, but it helps tracking those weird code
  * paths in the console code where we end up in places I want
  * locked without the console sempahore held).
  */
 static int console_locked, console_suspended;
 /*
  * If exclusive_console is non-NULL then only this console is to be printed to.
  */
 static struct console *exclusive_console;
 /*
  *	Array of consoles built from command line options (console=)
  */
 #define MAX_CMDLINECONSOLES 8
 static struct console_cmdline console_cmdline[MAX_CMDLINECONSOLES];
 static int selected_console = -1;
 static int preferred_console = -1;
 int console_set_on_cmdline;
 EXPORT_SYMBOL(console_set_on_cmdline);
 /* Flag: console code may call schedule() */
 static int console_may_schedule;
 /*
  * The printk log buffer consists of a chain of concatenated variable
  * length records. Every record starts with a record header, containing
  * the overall length of the record.
  *
  * The heads to the first and last entry in the buffer, as well as the
  * sequence numbers of these entries are maintained when messages are
  * stored.
  *
  * If the heads indicate available messages, the length in the header
  * tells the start next message. A length == 0 for the next message
  * indicates a wrap-around to the beginning of the buffer.
  *
  * Every record carries the monotonic timestamp in microseconds, as well as
  * the standard userspace syslog level and syslog facility. The usual
  * kernel messages use LOG_KERN; userspace-injected messages always carry
  * a matching syslog facility, by default LOG_USER. The origin of every
  * message can be reliably determined that way.
  *
  * The human readable log message directly follows the message header. The
  * length of the message text is stored in the header, the stored message
  * is not terminated.
  *
  * Optionally, a message can carry a dictionary of properties (key/value pairs),
  * to provide userspace with a machine-readable message context.
  *
  * Examples for well-defined, commonly used property names are:
  *   DEVICE=b12:8               device identifier
  *                                b12:8         block dev_t
  *                                c127:3        char dev_t
  *                                n8            netdev ifindex
  *                                +sound:card0  subsystem:devname
  *   SUBSYSTEM=pci              driver-core subsystem name
  *
  * Valid characters in property names are [a-zA-Z0-9.-_]. The plain text value
  * follows directly after a '=' character. Every property is terminated by
  * a '\0' character. The last property is not terminated.
  *
  * Example of a message structure:
  *   0000  ff 8f 00 00 00 00 00 00      monotonic time in nsec
  *   0008  34 00                        record is 52 bytes long
  *   000a        0b 00                  text is 11 bytes long
  *   000c              1f 00            dictionary is 23 bytes long
  *   000e                    03 00      LOG_KERN (facility) LOG_ERR (level)
  *   0010  69 74 27 73 20 61 20 6c      "it's a l"
  *         69 6e 65                     "ine"
  *   001b           44 45 56 49 43      "DEVIC"
  *         45 3d 62 38 3a 32 00 44      "E=b8:2\0D"
  *         52 49 56 45 52 3d 62 75      "RIVER=bu"
  *         67                           "g"
  *   0032     00 00 00                  padding to next message header
  *
  * The 'struct printk_log' buffer header must never be directly exported to
  * userspace, it is a kernel-private implementation detail that might
  * need to be changed in the future, when the requirements change.
  *
  * /dev/kmsg exports the structured data in the following line format:
  *   "level,sequnum,timestamp;<message text>\n"
  *
  * The optional key/value pairs are attached as continuation lines starting
  * with a space character and terminated by a newline. All possible
  * non-prinatable characters are escaped in the "\xff" notation.
  *
  * Users of the export format should ignore possible additional values
  * separated by ',', and find the message after the ';' character.
  */
 enum log_flags {
 	LOG_NOCONS	= 1,	/* already flushed, do not print to console */
 	LOG_NEWLINE	= 2,	/* text ended with a newline */
 	LOG_PREFIX	= 4,	/* text started with a prefix */
 	LOG_CONT	= 8,	/* text is a fragment of a continuation line */
 };
 struct printk_log {
 	u64 ts_nsec;		/* timestamp in nanoseconds */
 	u16 len;		/* length of entire record */
 	u16 text_len;		/* length of text buffer */
 	u16 dict_len;		/* length of dictionary buffer */
 	u8 facility;		/* syslog facility */
 	u8 flags:5;		/* internal record flags */
 	u8 level:3;		/* syslog level */
 };
 /*
  * The logbuf_lock protects kmsg buffer, indices, counters.  This can be taken
  * within the scheduler's rq lock. It must be released before calling
  * console_unlock() or anything else that might wake up a process.
  */
 static DEFINE_RAW_SPINLOCK(logbuf_lock);
 #ifdef CONFIG_PRINTK
 DECLARE_WAIT_QUEUE_HEAD(log_wait);
 /* the next printk record to read by syslog(READ) or /proc/kmsg */
 static u64 syslog_seq;
 static u32 syslog_idx;
 static enum log_flags syslog_prev;
 static size_t syslog_partial;
 /* index and sequence number of the first record stored in the buffer */
 static u64 log_first_seq;
 static u32 log_first_idx;
 /* index and sequence number of the next record to store in the buffer */
 static u64 log_next_seq;
 static u32 log_next_idx;
 /* the next printk record to write to the console */
 static u64 console_seq;
 static u32 console_idx;
 static enum log_flags console_prev;
 /* the next printk record to read after the last 'clear' command */
 static u64 clear_seq;
 static u32 clear_idx;
 #define PREFIX_MAX		32
 #define LOG_LINE_MAX		(1024 - PREFIX_MAX)
 /* record buffer */
 #if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS)
 #define LOG_ALIGN 4
 #else
 #define LOG_ALIGN __alignof__(struct printk_log)
 #endif
 #define __LOG_BUF_LEN (1 << CONFIG_LOG_BUF_SHIFT)
 static char __log_buf[__LOG_BUF_LEN] __aligned(LOG_ALIGN);
 static char *log_buf = __log_buf;
 static u32 log_buf_len = __LOG_BUF_LEN;
 /* Return log buffer address */
 char *log_buf_addr_get(void)
 {
 	return log_buf;
 }
 /* Return log buffer size */
 u32 log_buf_len_get(void)
 {
 	return log_buf_len;
 }
 /* human readable text of the record */
 static char *log_text(const struct printk_log *msg)
 {
 	return (char *)msg + sizeof(struct printk_log);
 }
 /* optional key/value pair dictionary attached to the record */
 static char *log_dict(const struct printk_log *msg)
 {
 	return (char *)msg + sizeof(struct printk_log) + msg->text_len;
 }
 /* get record by index; idx must point to valid msg */
 static struct printk_log *log_from_idx(u32 idx)
 {
 	struct printk_log *msg = (struct printk_log *)(log_buf + idx);
 	/*
 	 * A length == 0 record is the end of buffer marker. Wrap around and
 	 * read the message at the start of the buffer.
 	 */
 	if (!msg->len)
 		return (struct printk_log *)log_buf;
 	return msg;
 }
 /* get next record; idx must point to valid msg */
 static u32 log_next(u32 idx)
 {
 	struct printk_log *msg = (struct printk_log *)(log_buf + idx);
 	/* length == 0 indicates the end of the buffer; wrap */
 	/*
 	 * A length == 0 record is the end of buffer marker. Wrap around and
 	 * read the message at the start of the buffer as *this* one, and
 	 * return the one after that.
 	 */
 	if (!msg->len) {
 		msg = (struct printk_log *)log_buf;
 		return msg->len;
 	}
 	return idx + msg->len;
 }
 /*
  * Check whether there is enough free space for the given message.
  *
  * The same values of first_idx and next_idx mean that the buffer
  * is either empty or full.
  *
  * If the buffer is empty, we must respect the position of the indexes.
  * They cannot be reset to the beginning of the buffer.
  */
 static int logbuf_has_space(u32 msg_size, bool empty)
 {
 	u32 free;
 	if (log_next_idx > log_first_idx || empty)
 		free = max(log_buf_len - log_next_idx, log_first_idx);
 	else
 		free = log_first_idx - log_next_idx;
 	/*
 	 * We need space also for an empty header that signalizes wrapping
 	 * of the buffer.
 	 */
 	return free >= msg_size + sizeof(struct printk_log);
 }
 static int log_make_free_space(u32 msg_size)
 {
 	while (log_first_seq < log_next_seq) {
 		if (logbuf_has_space(msg_size, false))
 			return 0;
 		/* drop old messages until we have enough contiguous space */
 		log_first_idx = log_next(log_first_idx);
 		log_first_seq++;
 	}
 	/* sequence numbers are equal, so the log buffer is empty */
 	if (logbuf_has_space(msg_size, true))
 		return 0;
 	return -ENOMEM;
 }
 /* compute the message size including the padding bytes */
 static u32 msg_used_size(u16 text_len, u16 dict_len, u32 *pad_len)
 {
 	u32 size;
 	size = sizeof(struct printk_log) + text_len + dict_len;
 	*pad_len = (-size) & (LOG_ALIGN - 1);
 	size += *pad_len;
 	return size;
 }
 /*
  * Define how much of the log buffer we could take at maximum. The value
  * must be greater than two. Note that only half of the buffer is available
  * when the index points to the middle.
  */
 #define MAX_LOG_TAKE_PART 4
 static const char trunc_msg[] = "<truncated>";
 static u32 truncate_msg(u16 *text_len, u16 *trunc_msg_len,
 			u16 *dict_len, u32 *pad_len)
 {
 	/*
 	 * The message should not take the whole buffer. Otherwise, it might
 	 * get removed too soon.
 	 */
 	u32 max_text_len = log_buf_len / MAX_LOG_TAKE_PART;
 	if (*text_len > max_text_len)
 		*text_len = max_text_len;
 	/* enable the warning message */
 	*trunc_msg_len = strlen(trunc_msg);
 	/* disable the "dict" completely */
 	*dict_len = 0;
 	/* compute the size again, count also the warning message */
 	return msg_used_size(*text_len + *trunc_msg_len, 0, pad_len);
 }
 /* insert record into the buffer, discard old ones, update heads */
 static int log_store(int facility, int level,
 		     enum log_flags flags, u64 ts_nsec,
 		     const char *dict, u16 dict_len,
 		     const char *text, u16 text_len)
 {
 	struct printk_log *msg;
 	u32 size, pad_len;
 	u16 trunc_msg_len = 0;
 	/* number of '\0' padding bytes to next message */
 	size = msg_used_size(text_len, dict_len, &pad_len);
 	if (log_make_free_space(size)) {
 		/* truncate the message if it is too long for empty buffer */
 		size = truncate_msg(&text_len, &trunc_msg_len,
 				    &dict_len, &pad_len);
 		/* survive when the log buffer is too small for trunc_msg */
 		if (log_make_free_space(size))
 			return 0;
 	}
 	if (log_next_idx + size + sizeof(struct printk_log) > log_buf_len) {
 		/*
 		 * This message + an additional empty header does not fit
 		 * at the end of the buffer. Add an empty header with len == 0
 		 * to signify a wrap around.
 		 */
 		memset(log_buf + log_next_idx, 0, sizeof(struct printk_log));
 		log_next_idx = 0;
 	}
 	/* fill message */
 	msg = (struct printk_log *)(log_buf + log_next_idx);
 	memcpy(log_text(msg), text, text_len);
 	msg->text_len = text_len;
 	if (trunc_msg_len) {
 		memcpy(log_text(msg) + text_len, trunc_msg, trunc_msg_len);
 		msg->text_len += trunc_msg_len;
 	}
 	memcpy(log_dict(msg), dict, dict_len);
 	msg->dict_len = dict_len;
 	msg->facility = facility;
 	msg->level = level & 7;
 	msg->flags = flags & 0x1f;
 	if (ts_nsec > 0)
 		msg->ts_nsec = ts_nsec;
 	else
 		msg->ts_nsec = local_clock();
 	memset(log_dict(msg) + dict_len, 0, pad_len);
 	msg->len = size;
 	/* insert message */
 	log_next_idx += msg->len;
 	log_next_seq++;
 	return msg->text_len;
 }
 int dmesg_restrict = IS_ENABLED(CONFIG_SECURITY_DMESG_RESTRICT);
 static int syslog_action_restricted(int type)
 {
 	if (dmesg_restrict)
 		return 1;
 	/*
 	 * Unless restricted, we allow "read all" and "get buffer size"
 	 * for everybody.
 	 */
 	return type != SYSLOG_ACTION_READ_ALL &&
 	       type != SYSLOG_ACTION_SIZE_BUFFER;
 }
 int check_syslog_permissions(int type, bool from_file)
 {
 	/*
 	 * If this is from /proc/kmsg and we've already opened it, then we've
 	 * already done the capabilities checks at open time.
 	 */
 	if (from_file && type != SYSLOG_ACTION_OPEN)
 		return 0;
 	if (syslog_action_restricted(type)) {
 		if (capable(CAP_SYSLOG))
 			return 0;
 		/*
 		 * For historical reasons, accept CAP_SYS_ADMIN too, with
 		 * a warning.
 		 */
 		if (capable(CAP_SYS_ADMIN)) {
 			pr_warn_once("%s (%d): Attempt to access syslog with "
 				     "CAP_SYS_ADMIN but no CAP_SYSLOG "
 				     "(deprecated).\n",
 				 current->comm, task_pid_nr(current));
 			return 0;
 		}
 		return -EPERM;
 	}
 	return security_syslog(type);
 }
 /* /dev/kmsg - userspace message inject/listen interface */
 struct devkmsg_user {
 	u64 seq;
 	u32 idx;
 	enum log_flags prev;
 	struct mutex lock;
 	char buf[8192];
 };
 static ssize_t devkmsg_write(struct kiocb *iocb, struct iov_iter *from)
 {
 	char *buf, *line;
 	int i;
 	int level = default_message_loglevel;
 	int facility = 1;	/* LOG_USER */
 	size_t len = iocb->ki_nbytes;
 	ssize_t ret = len;
 	if (len > LOG_LINE_MAX)
 		return -EINVAL;
 	buf = kmalloc(len+1, GFP_KERNEL);
 	if (buf == NULL)
 		return -ENOMEM;
 	buf[len] = '\0';
 	if (copy_from_iter(buf, len, from) != len) {
 		kfree(buf);
 		return -EFAULT;
 	}
 	/*
 	 * Extract and skip the syslog prefix <[0-9]*>. Coming from userspace
 	 * the decimal value represents 32bit, the lower 3 bit are the log
 	 * level, the rest are the log facility.
 	 *
 	 * If no prefix or no userspace facility is specified, we
 	 * enforce LOG_USER, to be able to reliably distinguish
 	 * kernel-generated messages from userspace-injected ones.
 	 */
 	line = buf;
 	if (line[0] == '<') {
 		char *endp = NULL;
 		i = simple_strtoul(line+1, &endp, 10);
 		if (endp && endp[0] == '>') {
 			level = i & 7;
 			if (i >> 3)
 				facility = i >> 3;
 			endp++;
 			len -= endp - line;
 			line = endp;
 		}
 	}
 	printk_emit(facility, level, NULL, 0, "%s", line);
 	kfree(buf);
 	return ret;
 }
 static ssize_t devkmsg_read(struct file *file, char __user *buf,
 			    size_t count, loff_t *ppos)
 {
 	struct devkmsg_user *user = file->private_data;
 	struct printk_log *msg;
 	u64 ts_usec;
 	size_t i;
 	char cont = '-';
 	size_t len;
 	ssize_t ret;
 	if (!user)
 		return -EBADF;
 	ret = mutex_lock_interruptible(&user->lock);
 	if (ret)
 		return ret;
 	raw_spin_lock_irq(&logbuf_lock);
 	while (user->seq == log_next_seq) {
 		if (file->f_flags & O_NONBLOCK) {
 			ret = -EAGAIN;
 			raw_spin_unlock_irq(&logbuf_lock);
 			goto out;
 		}
 		raw_spin_unlock_irq(&logbuf_lock);
 		ret = wait_event_interruptible(log_wait,
 					       user->seq != log_next_seq);
 		if (ret)
 			goto out;
 		raw_spin_lock_irq(&logbuf_lock);
 	}
 	if (user->seq < log_first_seq) {
 		/* our last seen message is gone, return error and reset */
 		user->idx = log_first_idx;
 		user->seq = log_first_seq;
 		ret = -EPIPE;
 		raw_spin_unlock_irq(&logbuf_lock);
 		goto out;
 	}
 	msg = log_from_idx(user->idx);
 	ts_usec = msg->ts_nsec;
 	do_div(ts_usec, 1000);
 	/*
 	 * If we couldn't merge continuation line fragments during the print,
 	 * export the stored flags to allow an optional external merge of the
 	 * records. Merging the records isn't always neccessarily correct, like
 	 * when we hit a race during printing. In most cases though, it produces
 	 * better readable output. 'c' in the record flags mark the first
 	 * fragment of a line, '+' the following.
 	 */
 	if (msg->flags & LOG_CONT && !(user->prev & LOG_CONT))
 		cont = 'c';
 	else if ((msg->flags & LOG_CONT) ||
 		 ((user->prev & LOG_CONT) && !(msg->flags & LOG_PREFIX)))
 		cont = '+';
 	len = sprintf(user->buf, "%u,%llu,%llu,%c;",
 		      (msg->facility << 3) | msg->level,
 		      user->seq, ts_usec, cont);
 	user->prev = msg->flags;
 	/* escape non-printable characters */
 	for (i = 0; i < msg->text_len; i++) {
 		unsigned char c = log_text(msg)[i];
 		if (c < ' ' || c >= 127 || c == '\\')
 			len += sprintf(user->buf + len, "\\x%02x", c);
 		else
 			user->buf[len++] = c;
 	}
 	user->buf[len++] = '\n';
 	if (msg->dict_len) {
 		bool line = true;
 		for (i = 0; i < msg->dict_len; i++) {
 			unsigned char c = log_dict(msg)[i];
 			if (line) {
 				user->buf[len++] = ' ';
 				line = false;
 			}
 			if (c == '\0') {
 				user->buf[len++] = '\n';
 				line = true;
 				continue;
 			}
 			if (c < ' ' || c >= 127 || c == '\\') {
 				len += sprintf(user->buf + len, "\\x%02x", c);
 				continue;
 			}
 			user->buf[len++] = c;
 		}
 		user->buf[len++] = '\n';
 	}
 	user->idx = log_next(user->idx);
 	user->seq++;
 	raw_spin_unlock_irq(&logbuf_lock);
 	if (len > count) {
 		ret = -EINVAL;
 		goto out;
 	}
 	if (copy_to_user(buf, user->buf, len)) {
 		ret = -EFAULT;
 		goto out;
 	}
 	ret = len;
 out:
 	mutex_unlock(&user->lock);
 	return ret;
 }
 static loff_t devkmsg_llseek(struct file *file, loff_t offset, int whence)
 {
 	struct devkmsg_user *user = file->private_data;
 	loff_t ret = 0;
 	if (!user)
 		return -EBADF;
 	if (offset)
 		return -ESPIPE;
 	raw_spin_lock_irq(&logbuf_lock);
 	switch (whence) {
 	case SEEK_SET:
 		/* the first record */
 		user->idx = log_first_idx;
 		user->seq = log_first_seq;
 		break;
 	case SEEK_DATA:
 		/*
 		 * The first record after the last SYSLOG_ACTION_CLEAR,
 		 * like issued by 'dmesg -c'. Reading /dev/kmsg itself
 		 * changes no global state, and does not clear anything.
 		 */
 		user->idx = clear_idx;
 		user->seq = clear_seq;
 		break;
 	case SEEK_END:
 		/* after the last record */
 		user->idx = log_next_idx;
 		user->seq = log_next_seq;
 		break;
 	default:
 		ret = -EINVAL;
 	}
 	raw_spin_unlock_irq(&logbuf_lock);
 	return ret;
 }
 static unsigned int devkmsg_poll(struct file *file, poll_table *wait)
 {
 	struct devkmsg_user *user = file->private_data;
 	int ret = 0;
 	if (!user)
 		return POLLERR|POLLNVAL;
 	poll_wait(file, &log_wait, wait);
 	raw_spin_lock_irq(&logbuf_lock);
 	if (user->seq < log_next_seq) {
 		/* return error when data has vanished underneath us */
 		if (user->seq < log_first_seq)
 			ret = POLLIN|POLLRDNORM|POLLERR|POLLPRI;
 		else
 			ret = POLLIN|POLLRDNORM;
 	}
 	raw_spin_unlock_irq(&logbuf_lock);
 	return ret;
 }
 static int devkmsg_open(struct inode *inode, struct file *file)
 {
 	struct devkmsg_user *user;
 	int err;
 	/* write-only does not need any file context */
 	if ((file->f_flags & O_ACCMODE) == O_WRONLY)
 		return 0;
 	err = check_syslog_permissions(SYSLOG_ACTION_READ_ALL,
 				       SYSLOG_FROM_READER);
 	if (err)
 		return err;
 	user = kmalloc(sizeof(struct devkmsg_user), GFP_KERNEL);
 	if (!user)
 		return -ENOMEM;
 	mutex_init(&user->lock);
 	raw_spin_lock_irq(&logbuf_lock);
 	user->idx = log_first_idx;
 	user->seq = log_first_seq;
 	raw_spin_unlock_irq(&logbuf_lock);
 	file->private_data = user;
 	return 0;
 }
 static int devkmsg_release(struct inode *inode, struct file *file)
 {
 	struct devkmsg_user *user = file->private_data;
 	if (!user)
 		return 0;
 	mutex_destroy(&user->lock);
 	kfree(user);
 	return 0;
 }
 const struct file_operations kmsg_fops = {
 	.open = devkmsg_open,
 	.read = devkmsg_read,
 	.write_iter = devkmsg_write,
 	.llseek = devkmsg_llseek,
 	.poll = devkmsg_poll,
 	.release = devkmsg_release,
 };
 #ifdef CONFIG_KEXEC
 /*
  * This appends the listed symbols to /proc/vmcore
  *
  * /proc/vmcore is used by various utilities, like crash and makedumpfile to
  * obtain access to symbols that are otherwise very difficult to locate.  These
  * symbols are specifically used so that utilities can access and extract the
  * dmesg log from a vmcore file after a crash.
  */
 void log_buf_kexec_setup(void)
 {
 	VMCOREINFO_SYMBOL(log_buf);
 	VMCOREINFO_SYMBOL(log_buf_len);
 	VMCOREINFO_SYMBOL(log_first_idx);
 	VMCOREINFO_SYMBOL(log_next_idx);
 	/*
 	 * Export struct printk_log size and field offsets. User space tools can
 	 * parse it and detect any changes to structure down the line.
 	 */
 	VMCOREINFO_STRUCT_SIZE(printk_log);
 	VMCOREINFO_OFFSET(printk_log, ts_nsec);
 	VMCOREINFO_OFFSET(printk_log, len);
 	VMCOREINFO_OFFSET(printk_log, text_len);
 	VMCOREINFO_OFFSET(printk_log, dict_len);
 }
 #endif
 /* requested log_buf_len from kernel cmdline */
 static unsigned long __initdata new_log_buf_len;
 /* we practice scaling the ring buffer by powers of 2 */
 static void __init log_buf_len_update(unsigned size)
 {
 	if (size)
 		size = roundup_pow_of_two(size);
 	if (size > log_buf_len)
 		new_log_buf_len = size;
 }
 /* save requested log_buf_len since it's too early to process it */
 static int __init log_buf_len_setup(char *str)
 {
 	unsigned size = memparse(str, &str);
 	log_buf_len_update(size);
 	return 0;
 }
 early_param("log_buf_len", log_buf_len_setup);
 #ifdef CONFIG_SMP
 #define __LOG_CPU_MAX_BUF_LEN (1 << CONFIG_LOG_CPU_MAX_BUF_SHIFT)
 static void __init log_buf_add_cpu(void)
 {
 	unsigned int cpu_extra;
 	/*
 	 * archs should set up cpu_possible_bits properly with
 	 * set_cpu_possible() after setup_arch() but just in
 	 * case lets ensure this is valid.
 	 */
 	if (num_possible_cpus() == 1)
 		return;
 	cpu_extra = (num_possible_cpus() - 1) * __LOG_CPU_MAX_BUF_LEN;
 	/* by default this will only continue through for large > 64 CPUs */
 	if (cpu_extra <= __LOG_BUF_LEN / 2)
 		return;
 	pr_info("log_buf_len individual max cpu contribution: %d bytes\n",
 		__LOG_CPU_MAX_BUF_LEN);
 	pr_info("log_buf_len total cpu_extra contributions: %d bytes\n",
 		cpu_extra);
 	pr_info("log_buf_len min size: %d bytes\n", __LOG_BUF_LEN);
 	log_buf_len_update(cpu_extra + __LOG_BUF_LEN);
 }
 #else /* !CONFIG_SMP */
 static inline void log_buf_add_cpu(void) {}
 #endif /* CONFIG_SMP */
 void __init setup_log_buf(int early)
 {
 	unsigned long flags;
 	char *new_log_buf;
 	int free;
 	if (log_buf != __log_buf)
 		return;
 	if (!early && !new_log_buf_len)
 		log_buf_add_cpu();
 	if (!new_log_buf_len)
 		return;
 	if (early) {
 		new_log_buf =
 			memblock_virt_alloc(new_log_buf_len, LOG_ALIGN);
 	} else {
 		new_log_buf = memblock_virt_alloc_nopanic(new_log_buf_len,
 							  LOG_ALIGN);
 	}
 	if (unlikely(!new_log_buf)) {
 		pr_err("log_buf_len: %ld bytes not available\n",
 			new_log_buf_len);
 		return;
 	}
 	raw_spin_lock_irqsave(&logbuf_lock, flags);
 	log_buf_len = new_log_buf_len;
 	log_buf = new_log_buf;
 	new_log_buf_len = 0;
 	free = __LOG_BUF_LEN - log_next_idx;
 	memcpy(log_buf, __log_buf, __LOG_BUF_LEN);
 	raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 	pr_info("log_buf_len: %d bytes\n", log_buf_len);
 	pr_info("early log buf free: %d(%d%%)\n",
 		free, (free * 100) / __LOG_BUF_LEN);
 }
 static bool __read_mostly ignore_loglevel;
 static int __init ignore_loglevel_setup(char *str)
 {
 	ignore_loglevel = true;
 	pr_info("debug: ignoring loglevel setting.\n");
 	return 0;
 }
 early_param("ignore_loglevel", ignore_loglevel_setup);
 module_param(ignore_loglevel, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(ignore_loglevel,
 		 "ignore loglevel setting (prints all kernel messages to the console)");
 #ifdef CONFIG_BOOT_PRINTK_DELAY
 static int boot_delay; /* msecs delay after each printk during bootup */
 static unsigned long long loops_per_msec;	/* based on boot_delay */
 static int __init boot_delay_setup(char *str)
 {
 	unsigned long lpj;
 	lpj = preset_lpj ? preset_lpj : 1000000;	/* some guess */
 	loops_per_msec = (unsigned long long)lpj / 1000 * HZ;
 	get_option(&str, &boot_delay);
 	if (boot_delay > 10 * 1000)
 		boot_delay = 0;
 	pr_debug("boot_delay: %u, preset_lpj: %ld, lpj: %lu, "
 		"HZ: %d, loops_per_msec: %llu\n",
 		boot_delay, preset_lpj, lpj, HZ, loops_per_msec);
 	return 0;
 }
 early_param("boot_delay", boot_delay_setup);
 static void boot_delay_msec(int level)
 {
 	unsigned long long k;
 	unsigned long timeout;
 	if ((boot_delay == 0 || system_state != SYSTEM_BOOTING)
 		|| (level >= console_loglevel && !ignore_loglevel)) {
 		return;
 	}
 	k = (unsigned long long)loops_per_msec * boot_delay;
 	timeout = jiffies + msecs_to_jiffies(boot_delay);
 	while (k) {
 		k--;
 		cpu_relax();
 		/*
 		 * use (volatile) jiffies to prevent
 		 * compiler reduction; loop termination via jiffies
 		 * is secondary and may or may not happen.
 		 */
 		if (time_after(jiffies, timeout))
 			break;
 		touch_nmi_watchdog();
 	}
 }
 #else
 static inline void boot_delay_msec(int level)
 {
 }
 #endif
 static bool printk_time = IS_ENABLED(CONFIG_PRINTK_TIME);
 module_param_named(time, printk_time, bool, S_IRUGO | S_IWUSR);
 static size_t print_time(u64 ts, char *buf)
 {
 	unsigned long rem_nsec;
 	if (!printk_time)
 		return 0;
 	rem_nsec = do_div(ts, 1000000000);
 	if (!buf)
 		return snprintf(NULL, 0, "[%5lu.000000] ", (unsigned long)ts);
 	return sprintf(buf, "[%5lu.%06lu] ",
 		       (unsigned long)ts, rem_nsec / 1000);
 }
 static size_t print_prefix(const struct printk_log *msg, bool syslog, char *buf)
 {
 	size_t len = 0;
 	unsigned int prefix = (msg->facility << 3) | msg->level;
 	if (syslog) {
 		if (buf) {
 			len += sprintf(buf, "<%u>", prefix);
 		} else {
 			len += 3;
 			if (prefix > 999)
 				len += 3;
 			else if (prefix > 99)
 				len += 2;
 			else if (prefix > 9)
 				len++;
 		}
 	}
 	len += print_time(msg->ts_nsec, buf ? buf + len : NULL);
 	return len;
 }
 static size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
 			     bool syslog, char *buf, size_t size)
 {
 	const char *text = log_text(msg);
 	size_t text_size = msg->text_len;
 	bool prefix = true;
 	bool newline = true;
 	size_t len = 0;
 	if ((prev & LOG_CONT) && !(msg->flags & LOG_PREFIX))
 		prefix = false;
 	if (msg->flags & LOG_CONT) {
 		if ((prev & LOG_CONT) && !(prev & LOG_NEWLINE))
 			prefix = false;
 		if (!(msg->flags & LOG_NEWLINE))
 			newline = false;
 	}
 	do {
 		const char *next = memchr(text, '\n', text_size);
 		size_t text_len;
 		if (next) {
 			text_len = next - text;
 			next++;
 			text_size -= next - text;
 		} else {
 			text_len = text_size;
 		}
 		if (buf) {
 			if (print_prefix(msg, syslog, NULL) +
 			    text_len + 1 >= size - len)
 				break;
 			if (prefix)
 				len += print_prefix(msg, syslog, buf + len);
 			memcpy(buf + len, text, text_len);
 			len += text_len;
 			if (next || newline)
 				buf[len++] = '\n';
 		} else {
 			/* SYSLOG_ACTION_* buffer size only calculation */
 			if (prefix)
 				len += print_prefix(msg, syslog, NULL);
 			len += text_len;
 			if (next || newline)
 				len++;
 		}
 		prefix = true;
 		text = next;
 	} while (text);
 	return len;
 }
 static int syslog_print(char __user *buf, int size)
 {
 	char *text;
 	struct printk_log *msg;
 	int len = 0;
 	text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
 	if (!text)
 		return -ENOMEM;
 	while (size > 0) {
 		size_t n;
 		size_t skip;
 		raw_spin_lock_irq(&logbuf_lock);
 		if (syslog_seq < log_first_seq) {
 			/* messages are gone, move to first one */
 			syslog_seq = log_first_seq;
 			syslog_idx = log_first_idx;
 			syslog_prev = 0;
 			syslog_partial = 0;
 		}
 		if (syslog_seq == log_next_seq) {
 			raw_spin_unlock_irq(&logbuf_lock);
 			break;
 		}
 		skip = syslog_partial;
 		msg = log_from_idx(syslog_idx);
 		n = msg_print_text(msg, syslog_prev, true, text,
 				   LOG_LINE_MAX + PREFIX_MAX);
 		if (n - syslog_partial <= size) {
 			/* message fits into buffer, move forward */
 			syslog_idx = log_next(syslog_idx);
 			syslog_seq++;
 			syslog_prev = msg->flags;
 			n -= syslog_partial;
 			syslog_partial = 0;
 		} else if (!len){
 			/* partial read(), remember position */
 			n = size;
 			syslog_partial += n;
 		} else
 			n = 0;
 		raw_spin_unlock_irq(&logbuf_lock);
 		if (!n)
 			break;
 		if (copy_to_user(buf, text + skip, n)) {
 			if (!len)
 				len = -EFAULT;
 			break;
 		}
 		len += n;
 		size -= n;
 		buf += n;
 	}
 	kfree(text);
 	return len;
 }
 static int syslog_print_all(char __user *buf, int size, bool clear)
 {
 	char *text;
 	int len = 0;
 	text = kmalloc(LOG_LINE_MAX + PREFIX_MAX, GFP_KERNEL);
 	if (!text)
 		return -ENOMEM;
 	raw_spin_lock_irq(&logbuf_lock);
 	if (buf) {
 		u64 next_seq;
 		u64 seq;
 		u32 idx;
 		enum log_flags prev;
 		if (clear_seq < log_first_seq) {
 			/* messages are gone, move to first available one */
 			clear_seq = log_first_seq;
 			clear_idx = log_first_idx;
 		}
 		/*
 		 * Find first record that fits, including all following records,
 		 * into the user-provided buffer for this dump.
 		 */
 		seq = clear_seq;
 		idx = clear_idx;
 		prev = 0;
 		while (seq < log_next_seq) {
 			struct printk_log *msg = log_from_idx(idx);
 			len += msg_print_text(msg, prev, true, NULL, 0);
 			prev = msg->flags;
 			idx = log_next(idx);
 			seq++;
 		}
 		/* move first record forward until length fits into the buffer */
 		seq = clear_seq;
 		idx = clear_idx;
 		prev = 0;
 		while (len > size && seq < log_next_seq) {
 			struct printk_log *msg = log_from_idx(idx);
 			len -= msg_print_text(msg, prev, true, NULL, 0);
 			prev = msg->flags;
 			idx = log_next(idx);
 			seq++;
 		}
 		/* last message fitting into this dump */
 		next_seq = log_next_seq;
 		len = 0;
 		while (len >= 0 && seq < next_seq) {
 			struct printk_log *msg = log_from_idx(idx);
 			int textlen;
 			textlen = msg_print_text(msg, prev, true, text,
 						 LOG_LINE_MAX + PREFIX_MAX);
 			if (textlen < 0) {
 				len = textlen;
 				break;
 			}
 			idx = log_next(idx);
 			seq++;
 			prev = msg->flags;
 			raw_spin_unlock_irq(&logbuf_lock);
 			if (copy_to_user(buf + len, text, textlen))
 				len = -EFAULT;
 			else
 				len += textlen;
 			raw_spin_lock_irq(&logbuf_lock);
 			if (seq < log_first_seq) {
 				/* messages are gone, move to next one */
 				seq = log_first_seq;
 				idx = log_first_idx;
 				prev = 0;
 			}
 		}
 	}
 	if (clear) {
 		clear_seq = log_next_seq;
 		clear_idx = log_next_idx;
 	}
 	raw_spin_unlock_irq(&logbuf_lock);
 	kfree(text);
 	return len;
 }
 int do_syslog(int type, char __user *buf, int len, bool from_file)
 {
 	bool clear = false;
 	static int saved_console_loglevel = LOGLEVEL_DEFAULT;
 	int error;
 	error = check_syslog_permissions(type, from_file);
 	if (error)
 		goto out;
 	error = security_syslog(type);
 	if (error)
 		return error;
 	switch (type) {
 	case SYSLOG_ACTION_CLOSE:	/* Close log */
 		break;
 	case SYSLOG_ACTION_OPEN:	/* Open log */
 		break;
 	case SYSLOG_ACTION_READ:	/* Read from log */
 		error = -EINVAL;
 		if (!buf || len < 0)
 			goto out;
 		error = 0;
 		if (!len)
 			goto out;
 		if (!access_ok(VERIFY_WRITE, buf, len)) {
 			error = -EFAULT;
 			goto out;
 		}
 		error = wait_event_interruptible(log_wait,
 						 syslog_seq != log_next_seq);
 		if (error)
 			goto out;
 		error = syslog_print(buf, len);
 		break;
 	/* Read/clear last kernel messages */
 	case SYSLOG_ACTION_READ_CLEAR:
 		clear = true;
 		/* FALL THRU */
 	/* Read last kernel messages */
 	case SYSLOG_ACTION_READ_ALL:
 		error = -EINVAL;
 		if (!buf || len < 0)
 			goto out;
 		error = 0;
 		if (!len)
 			goto out;
 		if (!access_ok(VERIFY_WRITE, buf, len)) {
 			error = -EFAULT;
 			goto out;
 		}
 		error = syslog_print_all(buf, len, clear);
 		break;
 	/* Clear ring buffer */
 	case SYSLOG_ACTION_CLEAR:
 		syslog_print_all(NULL, 0, true);
 		break;
 	/* Disable logging to console */
 	case SYSLOG_ACTION_CONSOLE_OFF:
 		if (saved_console_loglevel == LOGLEVEL_DEFAULT)
 			saved_console_loglevel = console_loglevel;
 		console_loglevel = minimum_console_loglevel;
 		break;
 	/* Enable logging to console */
 	case SYSLOG_ACTION_CONSOLE_ON:
 		if (saved_console_loglevel != LOGLEVEL_DEFAULT) {
 			console_loglevel = saved_console_loglevel;
 			saved_console_loglevel = LOGLEVEL_DEFAULT;
 		}
 		break;
 	/* Set level of messages printed to console */
 	case SYSLOG_ACTION_CONSOLE_LEVEL:
 		error = -EINVAL;
 		if (len < 1 || len > 8)
 			goto out;
 		if (len < minimum_console_loglevel)
 			len = minimum_console_loglevel;
 		console_loglevel = len;
 		/* Implicitly re-enable logging to console */
 		saved_console_loglevel = LOGLEVEL_DEFAULT;
 		error = 0;
 		break;
 	/* Number of chars in the log buffer */
 	case SYSLOG_ACTION_SIZE_UNREAD:
 		raw_spin_lock_irq(&logbuf_lock);
 		if (syslog_seq < log_first_seq) {
 			/* messages are gone, move to first one */
 			syslog_seq = log_first_seq;
 			syslog_idx = log_first_idx;
 			syslog_prev = 0;
 			syslog_partial = 0;
 		}
 		if (from_file) {
 			/*
 			 * Short-cut for poll(/"proc/kmsg") which simply checks
 			 * for pending data, not the size; return the count of
 			 * records, not the length.
 			 */
 			error = log_next_seq - syslog_seq;
 		} else {
 			u64 seq = syslog_seq;
 			u32 idx = syslog_idx;
 			enum log_flags prev = syslog_prev;
 			error = 0;
 			while (seq < log_next_seq) {
 				struct printk_log *msg = log_from_idx(idx);
 				error += msg_print_text(msg, prev, true, NULL, 0);
 				idx = log_next(idx);
 				seq++;
 				prev = msg->flags;
 			}
 			error -= syslog_partial;
 		}
 		raw_spin_unlock_irq(&logbuf_lock);
 		break;
 	/* Size of the log buffer */
 	case SYSLOG_ACTION_SIZE_BUFFER:
 		error = log_buf_len;
 		break;
 	default:
 		error = -EINVAL;
 		break;
 	}
 out:
 	return error;
 }
 SYSCALL_DEFINE3(syslog, int, type, char __user *, buf, int, len)
 {
 	return do_syslog(type, buf, len, SYSLOG_FROM_READER);
 }
 /*
  * Call the console drivers, asking them to write out
  * log_buf[start] to log_buf[end - 1].
  * The console_lock must be held.
  */
 static void call_console_drivers(int level, const char *text, size_t len)
 {
 	struct console *con;
 	trace_console(text, len);
 	if (level >= console_loglevel && !ignore_loglevel)
 		return;
 	if (!console_drivers)
 		return;
 	for_each_console(con) {
 		if (exclusive_console && con != exclusive_console)
 			continue;
 		if (!(con->flags & CON_ENABLED))
 			continue;
 		if (!con->write)
 			continue;
 		if (!cpu_online(smp_processor_id()) &&
 		    !(con->flags & CON_ANYTIME))
 			continue;
 		con->write(con, text, len);
 	}
 }
 /*
  * Zap console related locks when oopsing.
  * To leave time for slow consoles to print a full oops,
  * only zap at most once every 30 seconds.
  */
 static void zap_locks(void)
 {
 	static unsigned long oops_timestamp;
 	if (time_after_eq(jiffies, oops_timestamp) &&
 	    !time_after(jiffies, oops_timestamp + 30 * HZ))
 		return;
 	oops_timestamp = jiffies;
 	debug_locks_off();
 	/* If a crash is occurring, make sure we can't deadlock */
 	raw_spin_lock_init(&logbuf_lock);
 	/* And make sure that we print immediately */
 	sema_init(&console_sem, 1);
 }
 /*
  * Check if we have any console that is capable of printing while cpu is
  * booting or shutting down. Requires console_sem.
  */
 static int have_callable_console(void)
 {
 	struct console *con;
 	for_each_console(con)
 		if (con->flags & CON_ANYTIME)
 			return 1;
 	return 0;
 }
 /*
  * Can we actually use the console at this time on this cpu?
  *
  * Console drivers may assume that per-cpu resources have been allocated. So
  * unless they're explicitly marked as being able to cope (CON_ANYTIME) don't
  * call them until this CPU is officially up.
  */
 static inline int can_use_console(unsigned int cpu)
 {
 	return cpu_online(cpu) || have_callable_console();
 }
 /*
  * Try to get console ownership to actually show the kernel
  * messages from a 'printk'. Return true (and with the
  * console_lock held, and 'console_locked' set) if it
  * is successful, false otherwise.
  */
 static int console_trylock_for_printk(void)
 {
 	unsigned int cpu = smp_processor_id();
 	if (!console_trylock())
 		return 0;
 	/*
 	 * If we can't use the console, we need to release the console
 	 * semaphore by hand to avoid flushing the buffer. We need to hold the
 	 * console semaphore in order to do this test safely.
 	 */
 	if (!can_use_console(cpu)) {
 		console_locked = 0;
 		up_console_sem();
 		return 0;
 	}
 	return 1;
 }
 int printk_delay_msec __read_mostly;
 static inline void printk_delay(void)
 {
 	if (unlikely(printk_delay_msec)) {
 		int m = printk_delay_msec;
 		while (m--) {
 			mdelay(1);
 			touch_nmi_watchdog();
 		}
 	}
 }
 /*
  * Continuation lines are buffered, and not committed to the record buffer
  * until the line is complete, or a race forces it. The line fragments
  * though, are printed immediately to the consoles to ensure everything has
  * reached the console in case of a kernel crash.
  */
 static struct cont {
 	char buf[LOG_LINE_MAX];
 	size_t len;			/* length == 0 means unused buffer */
 	size_t cons;			/* bytes written to console */
 	struct task_struct *owner;	/* task of first print*/
 	u64 ts_nsec;			/* time of first print */
 	u8 level;			/* log level of first message */
 	u8 facility;			/* log facility of first message */
 	enum log_flags flags;		/* prefix, newline flags */
 	bool flushed:1;			/* buffer sealed and committed */
 } cont;
 static void cont_flush(enum log_flags flags)
 {
 	if (cont.flushed)
 		return;
 	if (cont.len == 0)
 		return;
 	if (cont.cons) {
 		/*
 		 * If a fragment of this line was directly flushed to the
 		 * console; wait for the console to pick up the rest of the
 		 * line. LOG_NOCONS suppresses a duplicated output.
 		 */
 		log_store(cont.facility, cont.level, flags | LOG_NOCONS,
 			  cont.ts_nsec, NULL, 0, cont.buf, cont.len);
 		cont.flags = flags;
 		cont.flushed = true;
 	} else {
 		/*
 		 * If no fragment of this line ever reached the console,
 		 * just submit it to the store and free the buffer.
 		 */
 		log_store(cont.facility, cont.level, flags, 0,
 			  NULL, 0, cont.buf, cont.len);
 		cont.len = 0;
 	}
 }
 static bool cont_add(int facility, int level, const char *text, size_t len)
 {
 	if (cont.len && cont.flushed)
 		return false;
 	if (cont.len + len > sizeof(cont.buf)) {
 		/* the line gets too long, split it up in separate records */
 		cont_flush(LOG_CONT);
 		return false;
 	}
 	if (!cont.len) {
 		cont.facility = facility;
 		cont.level = level;
 		cont.owner = current;
 		cont.ts_nsec = local_clock();
 		cont.flags = 0;
 		cont.cons = 0;
 		cont.flushed = false;
 	}
 	memcpy(cont.buf + cont.len, text, len);
 	cont.len += len;
 	if (cont.len > (sizeof(cont.buf) * 80) / 100)
 		cont_flush(LOG_CONT);
 	return true;
 }
 static size_t cont_print_text(char *text, size_t size)
 {
 	size_t textlen = 0;
 	size_t len;
 	if (cont.cons == 0 && (console_prev & LOG_NEWLINE)) {
 		textlen += print_time(cont.ts_nsec, text);
 		size -= textlen;
 	}
 	len = cont.len - cont.cons;
 	if (len > 0) {
 		if (len+1 > size)
 			len = size-1;
 		memcpy(text + textlen, cont.buf + cont.cons, len);
 		textlen += len;
 		cont.cons = cont.len;
 	}
 	if (cont.flushed) {
 		if (cont.flags & LOG_NEWLINE)
 			text[textlen++] = '\n';
 		/* got everything, release buffer */
 		cont.len = 0;
 	}
 	return textlen;
 }
 asmlinkage int vprintk_emit(int facility, int level,
 			    const char *dict, size_t dictlen,
 			    const char *fmt, va_list args)
 {
 	static int recursion_bug;
 	static char textbuf[LOG_LINE_MAX];
 	char *text = textbuf;
 	size_t text_len = 0;
 	enum log_flags lflags = 0;
 	unsigned long flags;
 	int this_cpu;
 	int printed_len = 0;
 	bool in_sched = false;
 	/* cpu currently holding logbuf_lock in this function */
 	static unsigned int logbuf_cpu = UINT_MAX;
 	if (level == LOGLEVEL_SCHED) {
 		level = LOGLEVEL_DEFAULT;
 		in_sched = true;
 	}
 	boot_delay_msec(level);
 	printk_delay();
 	/* This stops the holder of console_sem just where we want him */
 	local_irq_save(flags);
 	this_cpu = smp_processor_id();
 	/*
 	 * Ouch, printk recursed into itself!
 	 */
 	if (unlikely(logbuf_cpu == this_cpu)) {
 		/*
 		 * If a crash is occurring during printk() on this CPU,
 		 * then try to get the crash message out but make sure
 		 * we can't deadlock. Otherwise just return to avoid the
 		 * recursion and return - but flag the recursion so that
 		 * it can be printed at the next appropriate moment:
 		 */
 		if (!oops_in_progress && !lockdep_recursing(current)) {
 			recursion_bug = 1;
 			local_irq_restore(flags);
 			return 0;
 		}
 		zap_locks();
 	}
 	lockdep_off();
 	raw_spin_lock(&logbuf_lock);
 	logbuf_cpu = this_cpu;
 	if (unlikely(recursion_bug)) {
 		static const char recursion_msg[] =
 			"BUG: recent printk recursion!";
 		recursion_bug = 0;
 		/* emit KERN_CRIT message */
 		printed_len += log_store(0, 2, LOG_PREFIX|LOG_NEWLINE, 0,
 					 NULL, 0, recursion_msg,
 					 strlen(recursion_msg));
 	}
 	/*
 	 * The printf needs to come first; we need the syslog
 	 * prefix which might be passed-in as a parameter.
 	 */
 	text_len = vscnprintf(text, sizeof(textbuf), fmt, args);
 	/* mark and strip a trailing newline */
 	if (text_len && text[text_len-1] == '\n') {
 		text_len--;
 		lflags |= LOG_NEWLINE;
 	}
 	/* strip kernel syslog prefix and extract log level or control flags */
 	if (facility == 0) {
 		int kern_level = printk_get_level(text);
 		if (kern_level) {
 			const char *end_of_header = printk_skip_level(text);
 			switch (kern_level) {
 			case '0' ... '7':
 				if (level == LOGLEVEL_DEFAULT)
 					level = kern_level - '0';
 				/* fallthrough */
 			case 'd':	/* KERN_DEFAULT */
 				lflags |= LOG_PREFIX;
 			}
 			/*
 			 * No need to check length here because vscnprintf
 			 * put '\0' at the end of the string. Only valid and
 			 * newly printed level is detected.
 			 */
 			text_len -= end_of_header - text;
 			text = (char *)end_of_header;
 		}
 	}
 	if (level == LOGLEVEL_DEFAULT)
 		level = default_message_loglevel;
 	if (dict)
 		lflags |= LOG_PREFIX|LOG_NEWLINE;
 	if (!(lflags & LOG_NEWLINE)) {
 		/*
 		 * Flush the conflicting buffer. An earlier newline was missing,
 		 * or another task also prints continuation lines.
 		 */
 		if (cont.len && (lflags & LOG_PREFIX || cont.owner != current))
 			cont_flush(LOG_NEWLINE);
 		/* buffer line if possible, otherwise store it right away */
 		if (cont_add(facility, level, text, text_len))
 			printed_len += text_len;
 		else
 			printed_len += log_store(facility, level,
 						 lflags | LOG_CONT, 0,
 						 dict, dictlen, text, text_len);
 	} else {
 		bool stored = false;
 		/*
 		 * If an earlier newline was missing and it was the same task,
 		 * either merge it with the current buffer and flush, or if
 		 * there was a race with interrupts (prefix == true) then just
 		 * flush it out and store this line separately.
 		 * If the preceding printk was from a different task and missed
 		 * a newline, flush and append the newline.
 		 */
 		if (cont.len) {
 			if (cont.owner == current && !(lflags & LOG_PREFIX))
 				stored = cont_add(facility, level, text,
 						  text_len);
 			cont_flush(LOG_NEWLINE);
 		}
 		if (stored)
 			printed_len += text_len;
 		else
 			printed_len += log_store(facility, level, lflags, 0,
 						 dict, dictlen, text, text_len);
 	}
 	logbuf_cpu = UINT_MAX;
 	raw_spin_unlock(&logbuf_lock);
 	lockdep_on();
 	local_irq_restore(flags);
 	/* If called from the scheduler, we can not call up(). */
 	if (!in_sched) {
 		lockdep_off();
 		/*
 		 * Disable preemption to avoid being preempted while holding
 		 * console_sem which would prevent anyone from printing to
 		 * console
 		 */
 		preempt_disable();
 		/*
 		 * Try to acquire and then immediately release the console
 		 * semaphore.  The release will print out buffers and wake up
 		 * /dev/kmsg and syslog() users.
 		 */
 		if (console_trylock_for_printk())
 			console_unlock();
 		preempt_enable();
 		lockdep_on();
 	}
 	return printed_len;
 }
 EXPORT_SYMBOL(vprintk_emit);
 asmlinkage int vprintk(const char *fmt, va_list args)
 {
 	return vprintk_emit(0, LOGLEVEL_DEFAULT, NULL, 0, fmt, args);
 }
 EXPORT_SYMBOL(vprintk);
 asmlinkage int printk_emit(int facility, int level,
 			   const char *dict, size_t dictlen,
 			   const char *fmt, ...)
 {
 	va_list args;
 	int r;
 	va_start(args, fmt);
 	r = vprintk_emit(facility, level, dict, dictlen, fmt, args);
 	va_end(args);
 	return r;
 }
 EXPORT_SYMBOL(printk_emit);
 int vprintk_default(const char *fmt, va_list args)
 {
 	int r;
 #ifdef CONFIG_KGDB_KDB
 	if (unlikely(kdb_trap_printk)) {
 		r = vkdb_printf(KDB_MSGSRC_PRINTK, fmt, args);
 		return r;
 	}
 #endif
 	r = vprintk_emit(0, LOGLEVEL_DEFAULT, NULL, 0, fmt, args);
 	return r;
 }
 EXPORT_SYMBOL_GPL(vprintk_default);
 /*
  * This allows printk to be diverted to another function per cpu.
  * This is useful for calling printk functions from within NMI
  * without worrying about race conditions that can lock up the
  * box.
  */
 DEFINE_PER_CPU(printk_func_t, printk_func) = vprintk_default;
 /**
  * printk - print a kernel message
  * @fmt: format string
  *
  * This is printk(). It can be called from any context. We want it to work.
  *
  * We try to grab the console_lock. If we succeed, it's easy - we log the
  * output and call the console drivers.  If we fail to get the semaphore, we
  * place the output into the log buffer and return. The current holder of
  * the console_sem will notice the new output in console_unlock(); and will
  * send it to the consoles before releasing the lock.
  *
  * One effect of this deferred printing is that code which calls printk() and
  * then changes console_loglevel may break. This is because console_loglevel
  * is inspected when the actual printing occurs.
  *
  * See also:
  * printf(3)
  *
  * See the vsnprintf() documentation for format string extensions over C99.
  */
 asmlinkage __visible int printk(const char *fmt, ...)
 {
 	printk_func_t vprintk_func;
 	va_list args;
 	int r;
 	va_start(args, fmt);
 	/*
 	 * If a caller overrides the per_cpu printk_func, then it needs
 	 * to disable preemption when calling printk(). Otherwise
 	 * the printk_func should be set to the default. No need to
 	 * disable preemption here.
 	 */
 	vprintk_func = this_cpu_read(printk_func);
 	r = vprintk_func(fmt, args);
 	va_end(args);
 	return r;
 }
 EXPORT_SYMBOL(printk);
 #else /* CONFIG_PRINTK */
 #define LOG_LINE_MAX		0
 #define PREFIX_MAX		0
 static u64 syslog_seq;
 static u32 syslog_idx;
 static u64 console_seq;
 static u32 console_idx;
 static enum log_flags syslog_prev;
 static u64 log_first_seq;
 static u32 log_first_idx;
 static u64 log_next_seq;
 static enum log_flags console_prev;
 static struct cont {
 	size_t len;
 	size_t cons;
 	u8 level;
 	bool flushed:1;
 } cont;
 static struct printk_log *log_from_idx(u32 idx) { return NULL; }
 static u32 log_next(u32 idx) { return 0; }
 static void call_console_drivers(int level, const char *text, size_t len) {}
 static size_t msg_print_text(const struct printk_log *msg, enum log_flags prev,
 			     bool syslog, char *buf, size_t size) { return 0; }
 static size_t cont_print_text(char *text, size_t size) { return 0; }
 /* Still needs to be defined for users */
 DEFINE_PER_CPU(printk_func_t, printk_func);
 #endif /* CONFIG_PRINTK */
 #ifdef CONFIG_EARLY_PRINTK
 struct console *early_console;
 asmlinkage __visible void early_printk(const char *fmt, ...)
 {
 	va_list ap;
 	char buf[512];
 	int n;
 	if (!early_console)
 		return;
 	va_start(ap, fmt);
 	n = vscnprintf(buf, sizeof(buf), fmt, ap);
 	va_end(ap);
 	early_console->write(early_console, buf, n);
 }
 #endif
 static int __add_preferred_console(char *name, int idx, char *options,
 				   char *brl_options)
 {
 	struct console_cmdline *c;
 	int i;
 	/*
 	 *	See if this tty is not yet registered, and
 	 *	if we have a slot free.
 	 */
 	for (i = 0, c = console_cmdline;
 	     i < MAX_CMDLINECONSOLES && c->name[0];
 	     i++, c++) {
 		if (strcmp(c->name, name) == 0 && c->index == idx) {
 			if (!brl_options)
 				selected_console = i;
 			return 0;
 		}
 	}
 	if (i == MAX_CMDLINECONSOLES)
 		return -E2BIG;
 	if (!brl_options)
 		selected_console = i;
 	strlcpy(c->name, name, sizeof(c->name));
 	c->options = options;
 	braille_set_options(c, brl_options);
 	c->index = idx;
 	return 0;
 }
 /*
  * Set up a console.  Called via do_early_param() in init/main.c
  * for each "console=" parameter in the boot command line.
  */
 static int __init console_setup(char *str)
 {
 	char buf[sizeof(console_cmdline[0].name) + 4]; /* 4 for "ttyS" */
 	char *s, *options, *brl_options = NULL;
 	int idx;
 	if (_braille_console_setup(&str, &brl_options))
 		return 1;
 	/*
 	 * Decode str into name, index, options.
 	 */
 	if (str[0] >= '0' && str[0] <= '9') {
 		strcpy(buf, "ttyS");
 		strncpy(buf + 4, str, sizeof(buf) - 5);
 	} else {
 		strncpy(buf, str, sizeof(buf) - 1);
 	}
 	buf[sizeof(buf) - 1] = 0;
 	options = strchr(str, ',');
 	if (options)
 		*(options++) = 0;
 #ifdef __sparc__
 	if (!strcmp(str, "ttya"))
 		strcpy(buf, "ttyS0");
 	if (!strcmp(str, "ttyb"))
 		strcpy(buf, "ttyS1");
 #endif
 	for (s = buf; *s; s++)
 		if (isdigit(*s) || *s == ',')
 			break;
 	idx = simple_strtoul(s, NULL, 10);
 	*s = 0;
 	__add_preferred_console(buf, idx, options, brl_options);
 	console_set_on_cmdline = 1;
 	return 1;
 }
 __setup("console=", console_setup);
 /**
  * add_preferred_console - add a device to the list of preferred consoles.
  * @name: device name
  * @idx: device index
  * @options: options for this console
  *
  * The last preferred console added will be used for kernel messages
  * and stdin/out/err for init.  Normally this is used by console_setup
  * above to handle user-supplied console arguments; however it can also
  * be used by arch-specific code either to override the user or more
  * commonly to provide a default console (ie from PROM variables) when
  * the user has not supplied one.
  */
 int add_preferred_console(char *name, int idx, char *options)
 {
 	return __add_preferred_console(name, idx, options, NULL);
 }
 int update_console_cmdline(char *name, int idx, char *name_new, int idx_new, char *options)
 {
 	struct console_cmdline *c;
 	int i;
 	for (i = 0, c = console_cmdline;
 	     i < MAX_CMDLINECONSOLES && c->name[0];
 	     i++, c++)
 		if (strcmp(c->name, name) == 0 && c->index == idx) {
 			strlcpy(c->name, name_new, sizeof(c->name));
 			c->options = options;
 			c->index = idx_new;
 			return i;
 		}
 	/* not found */
 	return -1;
 }
 bool console_suspend_enabled = true;
 EXPORT_SYMBOL(console_suspend_enabled);
 static int __init console_suspend_disable(char *str)
 {
 	console_suspend_enabled = false;
 	return 1;
 }
 __setup("no_console_suspend", console_suspend_disable);
 module_param_named(console_suspend, console_suspend_enabled,
 		bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(console_suspend, "suspend console during suspend"
 	" and hibernate operations");
 /**
  * suspend_console - suspend the console subsystem
  *
  * This disables printk() while we go into suspend states
  */
 void suspend_console(void)
 {
 	if (!console_suspend_enabled)
 		return;
 	printk("Suspending console(s) (use no_console_suspend to debug)\n");
 	console_lock();
 	console_suspended = 1;
 	up_console_sem();
 }
 void resume_console(void)
 {
 	if (!console_suspend_enabled)
 		return;
 	down_console_sem();
 	console_suspended = 0;
 	console_unlock();
 }
 /**
  * console_cpu_notify - print deferred console messages after CPU hotplug
  * @self: notifier struct
  * @action: CPU hotplug event
  * @hcpu: unused
  *
  * If printk() is called from a CPU that is not online yet, the messages
  * will be spooled but will not show up on the console.  This function is
  * called when a new CPU comes online (or fails to come up), and ensures
  * that any such output gets printed.
  */
 static int console_cpu_notify(struct notifier_block *self,
 	unsigned long action, void *hcpu)
 {
 	switch (action) {
 	case CPU_ONLINE:
 	case CPU_DEAD:
 	case CPU_DOWN_FAILED:
 	case CPU_UP_CANCELED:
 		console_lock();
 		console_unlock();
 	}
 	return NOTIFY_OK;
 }
 /**
  * console_lock - lock the console system for exclusive use.
  *
  * Acquires a lock which guarantees that the caller has
  * exclusive access to the console system and the console_drivers list.
  *
  * Can sleep, returns nothing.
  */
 void console_lock(void)
 {
 	might_sleep();
 	down_console_sem();
 	if (console_suspended)
 		return;
 	console_locked = 1;
 	console_may_schedule = 1;
 }
 EXPORT_SYMBOL(console_lock);
 /**
  * console_trylock - try to lock the console system for exclusive use.
  *
  * Try to acquire a lock which guarantees that the caller has exclusive
  * access to the console system and the console_drivers list.
  *
  * returns 1 on success, and 0 on failure to acquire the lock.
  */
 int console_trylock(void)
 {
 	if (down_trylock_console_sem())
 		return 0;
 	if (console_suspended) {
 		up_console_sem();
 		return 0;
 	}
 	console_locked = 1;
 	console_may_schedule = 0;
 	return 1;
 }
 EXPORT_SYMBOL(console_trylock);
 int is_console_locked(void)
 {
 	return console_locked;
 }
 static void console_cont_flush(char *text, size_t size)
 {
 	unsigned long flags;
 	size_t len;
 	raw_spin_lock_irqsave(&logbuf_lock, flags);
 	if (!cont.len)
 		goto out;
 	/*
 	 * We still queue earlier records, likely because the console was
 	 * busy. The earlier ones need to be printed before this one, we
 	 * did not flush any fragment so far, so just let it queue up.
 	 */
 	if (console_seq < log_next_seq && !cont.cons)
 		goto out;
 	len = cont_print_text(text, size);
 	raw_spin_unlock(&logbuf_lock);
 	stop_critical_timings();
 	call_console_drivers(cont.level, text, len);
 	start_critical_timings();
 	local_irq_restore(flags);
 	return;
 out:
 	raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 }
 /**
  * console_unlock - unlock the console system
  *
  * Releases the console_lock which the caller holds on the console system
  * and the console driver list.
  *
  * While the console_lock was held, console output may have been buffered
  * by printk().  If this is the case, console_unlock(); emits
  * the output prior to releasing the lock.
  *
  * If there is output waiting, we wake /dev/kmsg and syslog() users.
  *
  * console_unlock(); may be called from any context.
  */
 void console_unlock(void)
 {
 	static char text[LOG_LINE_MAX + PREFIX_MAX];
 	static u64 seen_seq;
 	unsigned long flags;
 	bool wake_klogd = false;
 	bool retry;
 	if (console_suspended) {
 		up_console_sem();
 		return;
 	}
 	console_may_schedule = 0;
 	/* flush buffered message fragment immediately to console */
 	console_cont_flush(text, sizeof(text));
 again:
 	for (;;) {
 		struct printk_log *msg;
 		size_t len;
 		int level;
 		raw_spin_lock_irqsave(&logbuf_lock, flags);
 		if (seen_seq != log_next_seq) {
 			wake_klogd = true;
 			seen_seq = log_next_seq;
 		}
 		if (console_seq < log_first_seq) {
 			len = sprintf(text, "** %u printk messages dropped ** ",
 				      (unsigned)(log_first_seq - console_seq));
 			/* messages are gone, move to first one */
 			console_seq = log_first_seq;
 			console_idx = log_first_idx;
 			console_prev = 0;
 		} else {
 			len = 0;
 		}
 skip:
 		if (console_seq == log_next_seq)
 			break;
 		msg = log_from_idx(console_idx);
 		if (msg->flags & LOG_NOCONS) {
 			/*
 			 * Skip record we have buffered and already printed
 			 * directly to the console when we received it.
 			 */
 			console_idx = log_next(console_idx);
 			console_seq++;
 			/*
 			 * We will get here again when we register a new
 			 * CON_PRINTBUFFER console. Clear the flag so we
 			 * will properly dump everything later.
 			 */
 			msg->flags &= ~LOG_NOCONS;
 			console_prev = msg->flags;
 			goto skip;
 		}
 		level = msg->level;
 		len += msg_print_text(msg, console_prev, false,
 				      text + len, sizeof(text) - len);
 		console_idx = log_next(console_idx);
 		console_seq++;
 		console_prev = msg->flags;
 		raw_spin_unlock(&logbuf_lock);
 		stop_critical_timings();	/* don't trace print latency */
 		call_console_drivers(level, text, len);
 		start_critical_timings();
 		local_irq_restore(flags);
 	}
 	console_locked = 0;
 	/* Release the exclusive_console once it is used */
 	if (unlikely(exclusive_console))
 		exclusive_console = NULL;
 	raw_spin_unlock(&logbuf_lock);
 	up_console_sem();
 	/*
 	 * Someone could have filled up the buffer again, so re-check if there's
 	 * something to flush. In case we cannot trylock the console_sem again,
 	 * there's a new owner and the console_unlock() from them will do the
 	 * flush, no worries.
 	 */
 	raw_spin_lock(&logbuf_lock);
 	retry = console_seq != log_next_seq;
 	raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 	if (retry && console_trylock())
 		goto again;
 	if (wake_klogd)
 		wake_up_klogd();
 }
 EXPORT_SYMBOL(console_unlock);
 /**
  * console_conditional_schedule - yield the CPU if required
  *
  * If the console code is currently allowed to sleep, and
  * if this CPU should yield the CPU to another task, do
  * so here.
  *
  * Must be called within console_lock();.
  */
 void __sched console_conditional_schedule(void)
 {
 	if (console_may_schedule)
 		cond_resched();
 }
 EXPORT_SYMBOL(console_conditional_schedule);
 void console_unblank(void)
 {
 	struct console *c;
 	/*
 	 * console_unblank can no longer be called in interrupt context unless
 	 * oops_in_progress is set to 1..
 	 */
 	if (oops_in_progress) {
 		if (down_trylock_console_sem() != 0)
 			return;
 	} else
 		console_lock();
 	console_locked = 1;
 	console_may_schedule = 0;
 	for_each_console(c)
 		if ((c->flags & CON_ENABLED) && c->unblank)
 			c->unblank();
 	console_unlock();
 }
 /*
  * Return the console tty driver structure and its associated index
  */
 struct tty_driver *console_device(int *index)
 {
 	struct console *c;
 	struct tty_driver *driver = NULL;
 	console_lock();
 	for_each_console(c) {
 		if (!c->device)
 			continue;
 		driver = c->device(c, index);
 		if (driver)
 			break;
 	}
 	console_unlock();
 	return driver;
 }
 /*
  * Prevent further output on the passed console device so that (for example)
  * serial drivers can disable console output before suspending a port, and can
  * re-enable output afterwards.
  */
 void console_stop(struct console *console)
 {
 	console_lock();
 	console->flags &= ~CON_ENABLED;
 	console_unlock();
 }
 EXPORT_SYMBOL(console_stop);
 void console_start(struct console *console)
 {
 	console_lock();
 	console->flags |= CON_ENABLED;
 	console_unlock();
 }
 EXPORT_SYMBOL(console_start);
 static int __read_mostly keep_bootcon;
 static int __init keep_bootcon_setup(char *str)
 {
 	keep_bootcon = 1;
 	pr_info("debug: skip boot console de-registration.\n");
 	return 0;
 }
 early_param("keep_bootcon", keep_bootcon_setup);
 /*
  * The console driver calls this routine during kernel initialization
  * to register the console printing procedure with printk() and to
  * print any messages that were printed by the kernel before the
  * console driver was initialized.
  *
  * This can happen pretty early during the boot process (because of
  * early_printk) - sometimes before setup_arch() completes - be careful
  * of what kernel features are used - they may not be initialised yet.
  *
  * There are two types of consoles - bootconsoles (early_printk) and
  * "real" consoles (everything which is not a bootconsole) which are
  * handled differently.
  *  - Any number of bootconsoles can be registered at any time.
  *  - As soon as a "real" console is registered, all bootconsoles
  *    will be unregistered automatically.
  *  - Once a "real" console is registered, any attempt to register a
  *    bootconsoles will be rejected
  */
 void register_console(struct console *newcon)
 {
 	int i;
 	unsigned long flags;
 	struct console *bcon = NULL;
 	struct console_cmdline *c;
 	if (console_drivers)
 		for_each_console(bcon)
 			if (WARN(bcon == newcon,
 					"console '%s%d' already registered\n",
 					bcon->name, bcon->index))
 				return;
 	/*
 	 * before we register a new CON_BOOT console, make sure we don't
 	 * already have a valid console
 	 */
 	if (console_drivers && newcon->flags & CON_BOOT) {
 		/* find the last or real console */
 		for_each_console(bcon) {
 			if (!(bcon->flags & CON_BOOT)) {
 				pr_info("Too late to register bootconsole %s%d\n",
 					newcon->name, newcon->index);
 				return;
 			}
 		}
 	}
 	if (console_drivers && console_drivers->flags & CON_BOOT)
 		bcon = console_drivers;
 	if (preferred_console < 0 || bcon || !console_drivers)
 		preferred_console = selected_console;
 	if (newcon->early_setup)
 		newcon->early_setup();
 	/*
 	 *	See if we want to use this console driver. If we
 	 *	didn't select a console we take the first one
 	 *	that registers here.
 	 */
 	if (preferred_console < 0) {
 		if (newcon->index < 0)
 			newcon->index = 0;
 		if (newcon->setup == NULL ||
 		    newcon->setup(newcon, NULL) == 0) {
 			newcon->flags |= CON_ENABLED;
 			if (newcon->device) {
 				newcon->flags |= CON_CONSDEV;
 				preferred_console = 0;
 			}
 		}
 	}
 	/*
 	 *	See if this console matches one we selected on
 	 *	the command line.
 	 */
 	for (i = 0, c = console_cmdline;
 	     i < MAX_CMDLINECONSOLES && c->name[0];
 	     i++, c++) {
+		BUILD_BUG_ON(sizeof(c->name) != sizeof(newcon->name));
 		if (strcmp(c->name, newcon->name) != 0)
 			continue;
 		if (newcon->index >= 0 &&
 		    newcon->index != c->index)
 			continue;
 		if (newcon->index < 0)
 			newcon->index = c->index;
 		if (_braille_register_console(newcon, c))
 			return;
 		if (newcon->setup &&
 		    newcon->setup(newcon, console_cmdline[i].options) != 0)
 			break;
 		newcon->flags |= CON_ENABLED;
 		newcon->index = c->index;
 		if (i == selected_console) {
 			newcon->flags |= CON_CONSDEV;
 			preferred_console = selected_console;
 		}
 		break;
 	}
 	if (!(newcon->flags & CON_ENABLED))
 		return;
 	/*
 	 * If we have a bootconsole, and are switching to a real console,
 	 * don't print everything out again, since when the boot console, and
 	 * the real console are the same physical device, it's annoying to
 	 * see the beginning boot messages twice
 	 */
 	if (bcon && ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV))
 		newcon->flags &= ~CON_PRINTBUFFER;
 	/*
 	 *	Put this console in the list - keep the
 	 *	preferred driver at the head of the list.
 	 */
 	console_lock();
 	if ((newcon->flags & CON_CONSDEV) || console_drivers == NULL) {
 		newcon->next = console_drivers;
 		console_drivers = newcon;
 		if (newcon->next)
 			newcon->next->flags &= ~CON_CONSDEV;
 	} else {
 		newcon->next = console_drivers->next;
 		console_drivers->next = newcon;
 	}
 	if (newcon->flags & CON_PRINTBUFFER) {
 		/*
 		 * console_unlock(); will print out the buffered messages
 		 * for us.
 		 */
 		raw_spin_lock_irqsave(&logbuf_lock, flags);
 		console_seq = syslog_seq;
 		console_idx = syslog_idx;
 		console_prev = syslog_prev;
 		raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 		/*
 		 * We're about to replay the log buffer.  Only do this to the
 		 * just-registered console to avoid excessive message spam to
 		 * the already-registered consoles.
 		 */
 		exclusive_console = newcon;
 	}
 	console_unlock();
 	console_sysfs_notify();
 	/*
 	 * By unregistering the bootconsoles after we enable the real console
 	 * we get the "console xxx enabled" message on all the consoles -
 	 * boot consoles, real consoles, etc - this is to ensure that end
 	 * users know there might be something in the kernel's log buffer that
 	 * went to the bootconsole (that they do not see on the real console)
 	 */
 	pr_info("%sconsole [%s%d] enabled\n",
 		(newcon->flags & CON_BOOT) ? "boot" : "" ,
 		newcon->name, newcon->index);
 	if (bcon &&
 	    ((newcon->flags & (CON_CONSDEV | CON_BOOT)) == CON_CONSDEV) &&
 	    !keep_bootcon) {
 		/* We need to iterate through all boot consoles, to make
 		 * sure we print everything out, before we unregister them.
 		 */
 		for_each_console(bcon)
 			if (bcon->flags & CON_BOOT)
 				unregister_console(bcon);
 	}
 }
 EXPORT_SYMBOL(register_console);
 int unregister_console(struct console *console)
 {
         struct console *a, *b;
 	int res;
 	pr_info("%sconsole [%s%d] disabled\n",
 		(console->flags & CON_BOOT) ? "boot" : "" ,
 		console->name, console->index);
 	res = _braille_unregister_console(console);
 	if (res)
 		return res;
 	res = 1;
 	console_lock();
 	if (console_drivers == console) {
 		console_drivers=console->next;
 		res = 0;
 	} else if (console_drivers) {
 		for (a=console_drivers->next, b=console_drivers ;
 		     a; b=a, a=b->next) {
 			if (a == console) {
 				b->next = a->next;
 				res = 0;
 				break;
 			}
 		}
 	}
 	/*
 	 * If this isn't the last console and it has CON_CONSDEV set, we
 	 * need to set it on the next preferred console.
 	 */
 	if (console_drivers != NULL && console->flags & CON_CONSDEV)
 		console_drivers->flags |= CON_CONSDEV;
 	console->flags &= ~CON_ENABLED;
 	console_unlock();
 	console_sysfs_notify();
 	return res;
 }
 EXPORT_SYMBOL(unregister_console);
 static int __init printk_late_init(void)
 {
 	struct console *con;
 	for_each_console(con) {
 		if (!keep_bootcon && con->flags & CON_BOOT) {
 			unregister_console(con);
 		}
 	}
 	hotcpu_notifier(console_cpu_notify, 0);
 	return 0;
 }
 late_initcall(printk_late_init);
 #if defined CONFIG_PRINTK
 /*
  * Delayed printk version, for scheduler-internal messages:
  */
 #define PRINTK_PENDING_WAKEUP	0x01
 #define PRINTK_PENDING_OUTPUT	0x02
 static DEFINE_PER_CPU(int, printk_pending);
 static void wake_up_klogd_work_func(struct irq_work *irq_work)
 {
 	int pending = __this_cpu_xchg(printk_pending, 0);
 	if (pending & PRINTK_PENDING_OUTPUT) {
 		/* If trylock fails, someone else is doing the printing */
 		if (console_trylock())
 			console_unlock();
 	}
 	if (pending & PRINTK_PENDING_WAKEUP)
 		wake_up_interruptible(&log_wait);
 }
 static DEFINE_PER_CPU(struct irq_work, wake_up_klogd_work) = {
 	.func = wake_up_klogd_work_func,
 	.flags = IRQ_WORK_LAZY,
 };
 void wake_up_klogd(void)
 {
 	preempt_disable();
 	if (waitqueue_active(&log_wait)) {
 		this_cpu_or(printk_pending, PRINTK_PENDING_WAKEUP);
 		irq_work_queue(this_cpu_ptr(&wake_up_klogd_work));
 	}
 	preempt_enable();
 }
 int printk_deferred(const char *fmt, ...)
 {
 	va_list args;
 	int r;
 	preempt_disable();
 	va_start(args, fmt);
 	r = vprintk_emit(0, LOGLEVEL_SCHED, NULL, 0, fmt, args);
 	va_end(args);
 	__this_cpu_or(printk_pending, PRINTK_PENDING_OUTPUT);
 	irq_work_queue(this_cpu_ptr(&wake_up_klogd_work));
 	preempt_enable();
 	return r;
 }
 /*
  * printk rate limiting, lifted from the networking subsystem.
  *
  * This enforces a rate limit: not more than 10 kernel messages
  * every 5s to make a denial-of-service attack impossible.
  */
 DEFINE_RATELIMIT_STATE(printk_ratelimit_state, 5 * HZ, 10);
 int __printk_ratelimit(const char *func)
 {
 	return ___ratelimit(&printk_ratelimit_state, func);
 }
 EXPORT_SYMBOL(__printk_ratelimit);
 /**
  * printk_timed_ratelimit - caller-controlled printk ratelimiting
  * @caller_jiffies: pointer to caller's state
  * @interval_msecs: minimum interval between prints
  *
  * printk_timed_ratelimit() returns true if more than @interval_msecs
  * milliseconds have elapsed since the last time printk_timed_ratelimit()
  * returned true.
  */
 bool printk_timed_ratelimit(unsigned long *caller_jiffies,
 			unsigned int interval_msecs)
 {
 	unsigned long elapsed = jiffies - *caller_jiffies;
 	if (*caller_jiffies && elapsed <= msecs_to_jiffies(interval_msecs))
 		return false;
 	*caller_jiffies = jiffies;
 	return true;
 }
 EXPORT_SYMBOL(printk_timed_ratelimit);
 static DEFINE_SPINLOCK(dump_list_lock);
 static LIST_HEAD(dump_list);
 /**
  * kmsg_dump_register - register a kernel log dumper.
  * @dumper: pointer to the kmsg_dumper structure
  *
  * Adds a kernel log dumper to the system. The dump callback in the
  * structure will be called when the kernel oopses or panics and must be
  * set. Returns zero on success and %-EINVAL or %-EBUSY otherwise.
  */
 int kmsg_dump_register(struct kmsg_dumper *dumper)
 {
 	unsigned long flags;
 	int err = -EBUSY;
 	/* The dump callback needs to be set */
 	if (!dumper->dump)
 		return -EINVAL;
 	spin_lock_irqsave(&dump_list_lock, flags);
 	/* Don't allow registering multiple times */
 	if (!dumper->registered) {
 		dumper->registered = 1;
 		list_add_tail_rcu(&dumper->list, &dump_list);
 		err = 0;
 	}
 	spin_unlock_irqrestore(&dump_list_lock, flags);
 	return err;
 }
 EXPORT_SYMBOL_GPL(kmsg_dump_register);
 /**
  * kmsg_dump_unregister - unregister a kmsg dumper.
  * @dumper: pointer to the kmsg_dumper structure
  *
  * Removes a dump device from the system. Returns zero on success and
  * %-EINVAL otherwise.
  */
 int kmsg_dump_unregister(struct kmsg_dumper *dumper)
 {
 	unsigned long flags;
 	int err = -EINVAL;
 	spin_lock_irqsave(&dump_list_lock, flags);
 	if (dumper->registered) {
 		dumper->registered = 0;
 		list_del_rcu(&dumper->list);
 		err = 0;
 	}
 	spin_unlock_irqrestore(&dump_list_lock, flags);
 	synchronize_rcu();
 	return err;
 }
 EXPORT_SYMBOL_GPL(kmsg_dump_unregister);
 static bool always_kmsg_dump;
 module_param_named(always_kmsg_dump, always_kmsg_dump, bool, S_IRUGO | S_IWUSR);
 /**
  * kmsg_dump - dump kernel log to kernel message dumpers.
  * @reason: the reason (oops, panic etc) for dumping
  *
  * Call each of the registered dumper's dump() callback, which can
  * retrieve the kmsg records with kmsg_dump_get_line() or
  * kmsg_dump_get_buffer().
  */
 void kmsg_dump(enum kmsg_dump_reason reason)
 {
 	struct kmsg_dumper *dumper;
 	unsigned long flags;
 	if ((reason > KMSG_DUMP_OOPS) && !always_kmsg_dump)
 		return;
 	rcu_read_lock();
 	list_for_each_entry_rcu(dumper, &dump_list, list) {
 		if (dumper->max_reason && reason > dumper->max_reason)
 			continue;
 		/* initialize iterator with data about the stored records */
 		dumper->active = true;
 		raw_spin_lock_irqsave(&logbuf_lock, flags);
 		dumper->cur_seq = clear_seq;
 		dumper->cur_idx = clear_idx;
 		dumper->next_seq = log_next_seq;
 		dumper->next_idx = log_next_idx;
 		raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 		/* invoke dumper which will iterate over records */
 		dumper->dump(dumper, reason);
 		/* reset iterator */
 		dumper->active = false;
 	}
 	rcu_read_unlock();
 }
 /**
  * kmsg_dump_get_line_nolock - retrieve one kmsg log line (unlocked version)
  * @dumper: registered kmsg dumper
  * @syslog: include the "<4>" prefixes
  * @line: buffer to copy the line to
  * @size: maximum size of the buffer
  * @len: length of line placed into buffer
  *
  * Start at the beginning of the kmsg buffer, with the oldest kmsg
  * record, and copy one record into the provided buffer.
  *
  * Consecutive calls will return the next available record moving
  * towards the end of the buffer with the youngest messages.
  *
  * A return value of FALSE indicates that there are no more records to
  * read.
  *
  * The function is similar to kmsg_dump_get_line(), but grabs no locks.
  */
 bool kmsg_dump_get_line_nolock(struct kmsg_dumper *dumper, bool syslog,
 			       char *line, size_t size, size_t *len)
 {
 	struct printk_log *msg;
 	size_t l = 0;
 	bool ret = false;
 	if (!dumper->active)
 		goto out;
 	if (dumper->cur_seq < log_first_seq) {
 		/* messages are gone, move to first available one */
 		dumper->cur_seq = log_first_seq;
 		dumper->cur_idx = log_first_idx;
 	}
 	/* last entry */
 	if (dumper->cur_seq >= log_next_seq)
 		goto out;
 	msg = log_from_idx(dumper->cur_idx);
 	l = msg_print_text(msg, 0, syslog, line, size);
 	dumper->cur_idx = log_next(dumper->cur_idx);
 	dumper->cur_seq++;
 	ret = true;
 out:
 	if (len)
 		*len = l;
 	return ret;
 }
 /**
  * kmsg_dump_get_line - retrieve one kmsg log line
  * @dumper: registered kmsg dumper
  * @syslog: include the "<4>" prefixes
  * @line: buffer to copy the line to
  * @size: maximum size of the buffer
  * @len: length of line placed into buffer
  *
  * Start at the beginning of the kmsg buffer, with the oldest kmsg
  * record, and copy one record into the provided buffer.
  *
  * Consecutive calls will return the next available record moving
  * towards the end of the buffer with the youngest messages.
  *
  * A return value of FALSE indicates that there are no more records to
  * read.
  */
 bool kmsg_dump_get_line(struct kmsg_dumper *dumper, bool syslog,
 			char *line, size_t size, size_t *len)
 {
 	unsigned long flags;
 	bool ret;
 	raw_spin_lock_irqsave(&logbuf_lock, flags);
 	ret = kmsg_dump_get_line_nolock(dumper, syslog, line, size, len);
 	raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 	return ret;
 }
 EXPORT_SYMBOL_GPL(kmsg_dump_get_line);
 /**
  * kmsg_dump_get_buffer - copy kmsg log lines
  * @dumper: registered kmsg dumper
  * @syslog: include the "<4>" prefixes
  * @buf: buffer to copy the line to
  * @size: maximum size of the buffer
  * @len: length of line placed into buffer
  *
  * Start at the end of the kmsg buffer and fill the provided buffer
  * with as many of the the *youngest* kmsg records that fit into it.
  * If the buffer is large enough, all available kmsg records will be
  * copied with a single call.
  *
  * Consecutive calls will fill the buffer with the next block of
  * available older records, not including the earlier retrieved ones.
  *
  * A return value of FALSE indicates that there are no more records to
  * read.
  */
 bool kmsg_dump_get_buffer(struct kmsg_dumper *dumper, bool syslog,
 			  char *buf, size_t size, size_t *len)
 {
 	unsigned long flags;
 	u64 seq;
 	u32 idx;
 	u64 next_seq;
 	u32 next_idx;
 	enum log_flags prev;
 	size_t l = 0;
 	bool ret = false;
 	if (!dumper->active)
 		goto out;
 	raw_spin_lock_irqsave(&logbuf_lock, flags);
 	if (dumper->cur_seq < log_first_seq) {
 		/* messages are gone, move to first available one */
 		dumper->cur_seq = log_first_seq;
 		dumper->cur_idx = log_first_idx;
 	}
 	/* last entry */
 	if (dumper->cur_seq >= dumper->next_seq) {
 		raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 		goto out;
 	}
 	/* calculate length of entire buffer */
 	seq = dumper->cur_seq;
 	idx = dumper->cur_idx;
 	prev = 0;
 	while (seq < dumper->next_seq) {
 		struct printk_log *msg = log_from_idx(idx);
 		l += msg_print_text(msg, prev, true, NULL, 0);
 		idx = log_next(idx);
 		seq++;
 		prev = msg->flags;
 	}
 	/* move first record forward until length fits into the buffer */
 	seq = dumper->cur_seq;
 	idx = dumper->cur_idx;
 	prev = 0;
 	while (l > size && seq < dumper->next_seq) {
 		struct printk_log *msg = log_from_idx(idx);
 		l -= msg_print_text(msg, prev, true, NULL, 0);
 		idx = log_next(idx);
 		seq++;
 		prev = msg->flags;
 	}
 	/* last message in next interation */
 	next_seq = seq;
 	next_idx = idx;
 	l = 0;
 	while (seq < dumper->next_seq) {
 		struct printk_log *msg = log_from_idx(idx);
 		l += msg_print_text(msg, prev, syslog, buf + l, size - l);
 		idx = log_next(idx);
 		seq++;
 		prev = msg->flags;
 	}
 	dumper->next_seq = next_seq;
 	dumper->next_idx = next_idx;
 	ret = true;
 	raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 out:
 	if (len)
 		*len = l;
 	return ret;
 }
 EXPORT_SYMBOL_GPL(kmsg_dump_get_buffer);
 /**
  * kmsg_dump_rewind_nolock - reset the interator (unlocked version)
  * @dumper: registered kmsg dumper
  *
  * Reset the dumper's iterator so that kmsg_dump_get_line() and
  * kmsg_dump_get_buffer() can be called again and used multiple
  * times within the same dumper.dump() callback.
  *
  * The function is similar to kmsg_dump_rewind(), but grabs no locks.
  */
 void kmsg_dump_rewind_nolock(struct kmsg_dumper *dumper)
 {
 	dumper->cur_seq = clear_seq;
 	dumper->cur_idx = clear_idx;
 	dumper->next_seq = log_next_seq;
 	dumper->next_idx = log_next_idx;
 }
 /**
  * kmsg_dump_rewind - reset the interator
  * @dumper: registered kmsg dumper
  *
  * Reset the dumper's iterator so that kmsg_dump_get_line() and
  * kmsg_dump_get_buffer() can be called again and used multiple
  * times within the same dumper.dump() callback.
  */
 void kmsg_dump_rewind(struct kmsg_dumper *dumper)
 {
 	unsigned long flags;
 	raw_spin_lock_irqsave(&logbuf_lock, flags);
 	kmsg_dump_rewind_nolock(dumper);
 	raw_spin_unlock_irqrestore(&logbuf_lock, flags);
 }
 EXPORT_SYMBOL_GPL(kmsg_dump_rewind);
 static char dump_stack_arch_desc_str[128];
 /**
  * dump_stack_set_arch_desc - set arch-specific str to show with task dumps
  * @fmt: printf-style format string
  * @...: arguments for the format string
  *
  * The configured string will be printed right after utsname during task
  * dumps.  Usually used to add arch-specific system identifiers.  If an
  * arch wants to make use of such an ID string, it should initialize this
  * as soon as possible during boot.
  */
 void __init dump_stack_set_arch_desc(const char *fmt, ...)
 {
 	va_list args;
 	va_start(args, fmt);
 	vsnprintf(dump_stack_arch_desc_str, sizeof(dump_stack_arch_desc_str),
 		  fmt, args);
 	va_end(args);
 }
 /**
  * dump_stack_print_info - print generic debug info for dump_stack()
  * @log_lvl: log level
  *
  * Arch-specific dump_stack() implementations can use this function to
  * print out the same debug information as the generic dump_stack().
  */
 void dump_stack_print_info(const char *log_lvl)
 {
 	printk("%sCPU: %d PID: %d Comm: %.20s %s %s %.*s\n",
 	       log_lvl, raw_smp_processor_id(), current->pid, current->comm,
 	       print_tainted(), init_utsname()->release,
 	       (int)strcspn(init_utsname()->version, " "),
 	       init_utsname()->version);
 	if (dump_stack_arch_desc_str[0] != '\0')
 		printk("%sHardware name: %s\n",
 		       log_lvl, dump_stack_arch_desc_str);
 	print_worker_info(log_lvl, current);
 }
 /**
  * show_regs_print_info - print generic debug info for show_regs()
  * @log_lvl: log level
  *
  * show_regs() implementations can use this function to print out generic
  * debug information.
  */
 void show_regs_print_info(const char *log_lvl)
 {
 	dump_stack_print_info(log_lvl);
 	printk("%stask: %p ti: %p task.ti: %p\n",
 	       log_lvl, current, current_thread_info(),
 	       task_thread_info(current));
 }
 #endif

net/irda/ircomm/ircomm_tty.c

Diff comments View file @ bbbce51

 /*********************************************************************
  *
  * Filename:      ircomm_tty.c
  * Version:       1.0
  * Description:   IrCOMM serial TTY driver
  * Status:        Experimental.
  * Author:        Dag Brattli <dagb@cs.uit.no>
  * Created at:    Sun Jun  6 21:00:56 1999
  * Modified at:   Wed Feb 23 00:09:02 2000
  * Modified by:   Dag Brattli <dagb@cs.uit.no>
  * Sources:       serial.c and previous IrCOMM work by Takahide Higuchi
  *
  *     Copyright (c) 1999-2000 Dag Brattli, All Rights Reserved.
  *     Copyright (c) 2000-2003 Jean Tourrilhes <jt@hpl.hp.com>
  *
  *     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, see <http://www.gnu.org/licenses/>.
  *
  ********************************************************************/
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/slab.h>
 #include <linux/sched.h>
 #include <linux/seq_file.h>
 #include <linux/termios.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
 #include <linux/interrupt.h>
 #include <linux/device.h>		/* for MODULE_ALIAS_CHARDEV_MAJOR */
 #include <asm/uaccess.h>
 #include <net/irda/irda.h>
 #include <net/irda/irmod.h>
 #include <net/irda/ircomm_core.h>
 #include <net/irda/ircomm_param.h>
 #include <net/irda/ircomm_tty_attach.h>
 #include <net/irda/ircomm_tty.h>
 static int ircomm_tty_install(struct tty_driver *driver,
 		struct tty_struct *tty);
 static int  ircomm_tty_open(struct tty_struct *tty, struct file *filp);
 static void ircomm_tty_close(struct tty_struct * tty, struct file *filp);
 static int  ircomm_tty_write(struct tty_struct * tty,
 			     const unsigned char *buf, int count);
 static int  ircomm_tty_write_room(struct tty_struct *tty);
 static void ircomm_tty_throttle(struct tty_struct *tty);
 static void ircomm_tty_unthrottle(struct tty_struct *tty);
 static int  ircomm_tty_chars_in_buffer(struct tty_struct *tty);
 static void ircomm_tty_flush_buffer(struct tty_struct *tty);
 static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch);
 static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout);
 static void ircomm_tty_hangup(struct tty_struct *tty);
 static void ircomm_tty_do_softint(struct work_struct *work);
 static void ircomm_tty_shutdown(struct ircomm_tty_cb *self);
 static void ircomm_tty_stop(struct tty_struct *tty);
 static int ircomm_tty_data_indication(void *instance, void *sap,
 				      struct sk_buff *skb);
 static int ircomm_tty_control_indication(void *instance, void *sap,
 					 struct sk_buff *skb);
 static void ircomm_tty_flow_indication(void *instance, void *sap,
 				       LOCAL_FLOW cmd);
 #ifdef CONFIG_PROC_FS
 static const struct file_operations ircomm_tty_proc_fops;
 #endif /* CONFIG_PROC_FS */
 static struct tty_driver *driver;
 static hashbin_t *ircomm_tty = NULL;
 static const struct tty_operations ops = {
 	.install	 = ircomm_tty_install,
 	.open            = ircomm_tty_open,
 	.close           = ircomm_tty_close,
 	.write           = ircomm_tty_write,
 	.write_room      = ircomm_tty_write_room,
 	.chars_in_buffer = ircomm_tty_chars_in_buffer,
 	.flush_buffer    = ircomm_tty_flush_buffer,
 	.ioctl           = ircomm_tty_ioctl,	/* ircomm_tty_ioctl.c */
 	.tiocmget        = ircomm_tty_tiocmget,	/* ircomm_tty_ioctl.c */
 	.tiocmset        = ircomm_tty_tiocmset,	/* ircomm_tty_ioctl.c */
 	.throttle        = ircomm_tty_throttle,
 	.unthrottle      = ircomm_tty_unthrottle,
 	.send_xchar      = ircomm_tty_send_xchar,
 	.set_termios     = ircomm_tty_set_termios,
 	.stop            = ircomm_tty_stop,
 	.start           = ircomm_tty_start,
 	.hangup          = ircomm_tty_hangup,
 	.wait_until_sent = ircomm_tty_wait_until_sent,
 #ifdef CONFIG_PROC_FS
 	.proc_fops       = &ircomm_tty_proc_fops,
 #endif /* CONFIG_PROC_FS */
 };
 static void ircomm_port_raise_dtr_rts(struct tty_port *port, int raise)
 {
 	struct ircomm_tty_cb *self = container_of(port, struct ircomm_tty_cb,
 			port);
 	/*
 	 * Here, we use to lock those two guys, but as ircomm_param_request()
 	 * does it itself, I don't see the point (and I see the deadlock).
 	 * Jean II
 	 */
 	if (raise)
 		self->settings.dte |= IRCOMM_RTS | IRCOMM_DTR;
 	else
 		self->settings.dte &= ~(IRCOMM_RTS | IRCOMM_DTR);
 	ircomm_param_request(self, IRCOMM_DTE, TRUE);
 }
 static int ircomm_port_carrier_raised(struct tty_port *port)
 {
 	struct ircomm_tty_cb *self = container_of(port, struct ircomm_tty_cb,
 			port);
 	return self->settings.dce & IRCOMM_CD;
 }
 static const struct tty_port_operations ircomm_port_ops = {
 	.dtr_rts = ircomm_port_raise_dtr_rts,
 	.carrier_raised = ircomm_port_carrier_raised,
 };
 /*
  * Function ircomm_tty_init()
  *
  *    Init IrCOMM TTY layer/driver
  *
  */
 static int __init ircomm_tty_init(void)
 {
 	driver = alloc_tty_driver(IRCOMM_TTY_PORTS);
 	if (!driver)
 		return -ENOMEM;
 	ircomm_tty = hashbin_new(HB_LOCK);
 	if (ircomm_tty == NULL) {
 		net_err_ratelimited("%s(), can't allocate hashbin!\n",
 				    __func__);
 		put_tty_driver(driver);
 		return -ENOMEM;
 	}
 	driver->driver_name     = "ircomm";
 	driver->name            = "ircomm";
 	driver->major           = IRCOMM_TTY_MAJOR;
 	driver->minor_start     = IRCOMM_TTY_MINOR;
 	driver->type            = TTY_DRIVER_TYPE_SERIAL;
 	driver->subtype         = SERIAL_TYPE_NORMAL;
 	driver->init_termios    = tty_std_termios;
 	driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
 	driver->flags           = TTY_DRIVER_REAL_RAW;
 	tty_set_operations(driver, &ops);
 	if (tty_register_driver(driver)) {
 		net_err_ratelimited("%s(): Couldn't register serial driver\n",
 				    __func__);
 		put_tty_driver(driver);
 		return -1;
 	}
 	return 0;
 }
 static void __exit __ircomm_tty_cleanup(struct ircomm_tty_cb *self)
 {
 	IRDA_ASSERT(self != NULL, return;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
 	ircomm_tty_shutdown(self);
 	self->magic = 0;
 	tty_port_destroy(&self->port);
 	kfree(self);
 }
 /*
  * Function ircomm_tty_cleanup ()
  *
  *    Remove IrCOMM TTY layer/driver
  *
  */
 static void __exit ircomm_tty_cleanup(void)
 {
 	int ret;
 	ret = tty_unregister_driver(driver);
 	if (ret) {
 		net_err_ratelimited("%s(), failed to unregister driver\n",
 				    __func__);
 		return;
 	}
 	hashbin_delete(ircomm_tty, (FREE_FUNC) __ircomm_tty_cleanup);
 	put_tty_driver(driver);
 }
 /*
  * Function ircomm_startup (self)
  *
  *
  *
  */
 static int ircomm_tty_startup(struct ircomm_tty_cb *self)
 {
 	notify_t notify;
 	int ret = -ENODEV;
 	IRDA_ASSERT(self != NULL, return -1;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 	/* Check if already open */
 	if (test_and_set_bit(ASYNCB_INITIALIZED, &self->port.flags)) {
 		pr_debug("%s(), already open so break out!\n", __func__);
 		return 0;
 	}
 	/* Register with IrCOMM */
 	irda_notify_init(&notify);
 	/* These callbacks we must handle ourselves */
 	notify.data_indication       = ircomm_tty_data_indication;
 	notify.udata_indication      = ircomm_tty_control_indication;
 	notify.flow_indication       = ircomm_tty_flow_indication;
 	/* Use the ircomm_tty interface for these ones */
 	notify.disconnect_indication = ircomm_tty_disconnect_indication;
 	notify.connect_confirm       = ircomm_tty_connect_confirm;
 	notify.connect_indication    = ircomm_tty_connect_indication;
 	strlcpy(notify.name, "ircomm_tty", sizeof(notify.name));
 	notify.instance = self;
 	if (!self->ircomm) {
 		self->ircomm = ircomm_open(&notify, self->service_type,
 					   self->line);
 	}
 	if (!self->ircomm)
 		goto err;
 	self->slsap_sel = self->ircomm->slsap_sel;
 	/* Connect IrCOMM link with remote device */
 	ret = ircomm_tty_attach_cable(self);
 	if (ret < 0) {
 		net_err_ratelimited("%s(), error attaching cable!\n", __func__);
 		goto err;
 	}
 	return 0;
 err:
 	clear_bit(ASYNCB_INITIALIZED, &self->port.flags);
 	return ret;
 }
 /*
  * Function ircomm_block_til_ready (self, filp)
  *
  *
  *
  */
 static int ircomm_tty_block_til_ready(struct ircomm_tty_cb *self,
 		struct tty_struct *tty, struct file *filp)
 {
 	struct tty_port *port = &self->port;
 	DECLARE_WAITQUEUE(wait, current);
 	int		retval;
 	int		do_clocal = 0;
 	unsigned long	flags;
 	/*
 	 * If non-blocking mode is set, or the port is not enabled,
 	 * then make the check up front and then exit.
 	 */
 	if (test_bit(TTY_IO_ERROR, &tty->flags)) {
 		port->flags |= ASYNC_NORMAL_ACTIVE;
 		return 0;
 	}
 	if (filp->f_flags & O_NONBLOCK) {
 		/* nonblock mode is set */
 		if (tty->termios.c_cflag & CBAUD)
 			tty_port_raise_dtr_rts(port);
 		port->flags |= ASYNC_NORMAL_ACTIVE;
 		pr_debug("%s(), O_NONBLOCK requested!\n", __func__);
 		return 0;
 	}
 	if (tty->termios.c_cflag & CLOCAL) {
 		pr_debug("%s(), doing CLOCAL!\n", __func__);
 		do_clocal = 1;
 	}
 	/* Wait for carrier detect and the line to become
 	 * free (i.e., not in use by the callout).  While we are in
 	 * this loop, port->count is dropped by one, so that
 	 * mgsl_close() knows when to free things.  We restore it upon
 	 * exit, either normal or abnormal.
 	 */
 	retval = 0;
 	add_wait_queue(&port->open_wait, &wait);
 	pr_debug("%s(%d):block_til_ready before block on %s open_count=%d\n",
 		 __FILE__, __LINE__, tty->driver->name, port->count);
 	spin_lock_irqsave(&port->lock, flags);
 	port->count--;
 	port->blocked_open++;
 	spin_unlock_irqrestore(&port->lock, flags);
 	while (1) {
 		if (C_BAUD(tty) && test_bit(ASYNCB_INITIALIZED, &port->flags))
 			tty_port_raise_dtr_rts(port);
 		set_current_state(TASK_INTERRUPTIBLE);
 		if (tty_hung_up_p(filp) ||
 		    !test_bit(ASYNCB_INITIALIZED, &port->flags)) {
 			retval = (port->flags & ASYNC_HUP_NOTIFY) ?
 					-EAGAIN : -ERESTARTSYS;
 			break;
 		}
 		/*
 		 * Check if link is ready now. Even if CLOCAL is
 		 * specified, we cannot return before the IrCOMM link is
 		 * ready
 		 */
 		if (!test_bit(ASYNCB_CLOSING, &port->flags) &&
 		    (do_clocal || tty_port_carrier_raised(port)) &&
 		    self->state == IRCOMM_TTY_READY)
 		{
 			break;
 		}
 		if (signal_pending(current)) {
 			retval = -ERESTARTSYS;
 			break;
 		}
 		pr_debug("%s(%d):block_til_ready blocking on %s open_count=%d\n",
 			 __FILE__, __LINE__, tty->driver->name, port->count);
 		schedule();
 	}
 	__set_current_state(TASK_RUNNING);
 	remove_wait_queue(&port->open_wait, &wait);
 	spin_lock_irqsave(&port->lock, flags);
 	if (!tty_hung_up_p(filp))
 		port->count++;
 	port->blocked_open--;
 	spin_unlock_irqrestore(&port->lock, flags);
 	pr_debug("%s(%d):block_til_ready after blocking on %s open_count=%d\n",
 		 __FILE__, __LINE__, tty->driver->name, port->count);
 	if (!retval)
 		port->flags |= ASYNC_NORMAL_ACTIVE;
 	return retval;
 }
 static int ircomm_tty_install(struct tty_driver *driver, struct tty_struct *tty)
 {
 	struct ircomm_tty_cb *self;
 	unsigned int line = tty->index;
 	/* Check if instance already exists */
 	self = hashbin_lock_find(ircomm_tty, line, NULL);
 	if (!self) {
 		/* No, so make new instance */
 		self = kzalloc(sizeof(struct ircomm_tty_cb), GFP_KERNEL);
 		if (self == NULL)
 			return -ENOMEM;
 		tty_port_init(&self->port);
 		self->port.ops = &ircomm_port_ops;
 		self->magic = IRCOMM_TTY_MAGIC;
 		self->flow = FLOW_STOP;
 		self->line = line;
 		INIT_WORK(&self->tqueue, ircomm_tty_do_softint);
 		self->max_header_size = IRCOMM_TTY_HDR_UNINITIALISED;
 		self->max_data_size = IRCOMM_TTY_DATA_UNINITIALISED;
 		/* Init some important stuff */
 		init_timer(&self->watchdog_timer);
 		spin_lock_init(&self->spinlock);
 		/*
 		 * Force TTY into raw mode by default which is usually what
 		 * we want for IrCOMM and IrLPT. This way applications will
 		 * not have to twiddle with printcap etc.
 		 *
 		 * Note this is completely usafe and doesn't work properly
 		 */
 		tty->termios.c_iflag = 0;
 		tty->termios.c_oflag = 0;
 		/* Insert into hash */
 		hashbin_insert(ircomm_tty, (irda_queue_t *) self, line, NULL);
 	}
 	tty->driver_data = self;
 	return tty_port_install(&self->port, driver, tty);
 }
 /*
  * Function ircomm_tty_open (tty, filp)
  *
  *    This routine is called when a particular tty device is opened. This
  *    routine is mandatory; if this routine is not filled in, the attempted
  *    open will fail with ENODEV.
  */
 static int ircomm_tty_open(struct tty_struct *tty, struct file *filp)
 {
 	struct ircomm_tty_cb *self = tty->driver_data;
 	unsigned long	flags;
 	int ret;
 	/* ++ is not atomic, so this should be protected - Jean II */
 	spin_lock_irqsave(&self->port.lock, flags);
 	self->port.count++;
 	spin_unlock_irqrestore(&self->port.lock, flags);
 	tty_port_tty_set(&self->port, tty);
 	pr_debug("%s(), %s%d, count = %d\n", __func__ , tty->driver->name,
 		 self->line, self->port.count);
 	/* Not really used by us, but lets do it anyway */
 	self->port.low_latency = (self->port.flags & ASYNC_LOW_LATENCY) ? 1 : 0;
 	/*
 	 * If the port is the middle of closing, bail out now
 	 */
 	if (test_bit(ASYNCB_CLOSING, &self->port.flags)) {
 		/* Hm, why are we blocking on ASYNC_CLOSING if we
 		 * do return -EAGAIN/-ERESTARTSYS below anyway?
 		 * IMHO it's either not needed in the first place
 		 * or for some reason we need to make sure the async
 		 * closing has been finished - if so, wouldn't we
 		 * probably better sleep uninterruptible?
 		 */
 		if (wait_event_interruptible(self->port.close_wait,
 				!test_bit(ASYNCB_CLOSING, &self->port.flags))) {
 			net_warn_ratelimited("%s - got signal while blocking on ASYNC_CLOSING!\n",
 					     __func__);
 			return -ERESTARTSYS;
 		}
 #ifdef SERIAL_DO_RESTART
 		return (self->port.flags & ASYNC_HUP_NOTIFY) ?
 			-EAGAIN : -ERESTARTSYS;
 #else
 		return -EAGAIN;
 #endif
 	}
 	/* Check if this is a "normal" ircomm device, or an irlpt device */
 	if (self->line < 0x10) {
 		self->service_type = IRCOMM_3_WIRE | IRCOMM_9_WIRE;
 		self->settings.service_type = IRCOMM_9_WIRE; /* 9 wire as default */
 		/* Jan Kiszka -> add DSR/RI -> Conform to IrCOMM spec */
 		self->settings.dce = IRCOMM_CTS | IRCOMM_CD | IRCOMM_DSR | IRCOMM_RI; /* Default line settings */
 		pr_debug("%s(), IrCOMM device\n", __func__);
 	} else {
 		pr_debug("%s(), IrLPT device\n", __func__);
 		self->service_type = IRCOMM_3_WIRE_RAW;
 		self->settings.service_type = IRCOMM_3_WIRE_RAW; /* Default */
 	}
 	ret = ircomm_tty_startup(self);
 	if (ret)
 		return ret;
 	ret = ircomm_tty_block_til_ready(self, tty, filp);
 	if (ret) {
 		pr_debug("%s(), returning after block_til_ready with %d\n",
 			 __func__, ret);
 		return ret;
 	}
 	return 0;
 }
 /*
  * Function ircomm_tty_close (tty, filp)
  *
  *    This routine is called when a particular tty device is closed.
  *
  */
 static void ircomm_tty_close(struct tty_struct *tty, struct file *filp)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	struct tty_port *port = &self->port;
 	IRDA_ASSERT(self != NULL, return;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
 	if (tty_port_close_start(port, tty, filp) == 0)
 		return;
 	ircomm_tty_shutdown(self);
 	tty_driver_flush_buffer(tty);
 	tty_port_close_end(port, tty);
 	tty_port_tty_set(port, NULL);
 }
 /*
  * Function ircomm_tty_flush_buffer (tty)
  *
  *
  *
  */
 static void ircomm_tty_flush_buffer(struct tty_struct *tty)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	IRDA_ASSERT(self != NULL, return;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
 	/*
 	 * Let do_softint() do this to avoid race condition with
 	 * do_softint() ;-)
 	 */
 	schedule_work(&self->tqueue);
 }
 /*
  * Function ircomm_tty_do_softint (work)
  *
  *    We use this routine to give the write wakeup to the user at at a
  *    safe time (as fast as possible after write have completed). This
  *    can be compared to the Tx interrupt.
  */
 static void ircomm_tty_do_softint(struct work_struct *work)
 {
 	struct ircomm_tty_cb *self =
 		container_of(work, struct ircomm_tty_cb, tqueue);
 	struct tty_struct *tty;
 	unsigned long flags;
 	struct sk_buff *skb, *ctrl_skb;
 	if (!self || self->magic != IRCOMM_TTY_MAGIC)
 		return;
 	tty = tty_port_tty_get(&self->port);
 	if (!tty)
 		return;
 	/* Unlink control buffer */
 	spin_lock_irqsave(&self->spinlock, flags);
 	ctrl_skb = self->ctrl_skb;
 	self->ctrl_skb = NULL;
 	spin_unlock_irqrestore(&self->spinlock, flags);
 	/* Flush control buffer if any */
 	if(ctrl_skb) {
 		if(self->flow == FLOW_START)
 			ircomm_control_request(self->ircomm, ctrl_skb);
 		/* Drop reference count - see ircomm_ttp_data_request(). */
 		dev_kfree_skb(ctrl_skb);
 	}
 	if (tty->hw_stopped)
 		goto put;
 	/* Unlink transmit buffer */
 	spin_lock_irqsave(&self->spinlock, flags);
 	skb = self->tx_skb;
 	self->tx_skb = NULL;
 	spin_unlock_irqrestore(&self->spinlock, flags);
 	/* Flush transmit buffer if any */
 	if (skb) {
 		ircomm_tty_do_event(self, IRCOMM_TTY_DATA_REQUEST, skb, NULL);
 		/* Drop reference count - see ircomm_ttp_data_request(). */
 		dev_kfree_skb(skb);
 	}
 	/* Check if user (still) wants to be waken up */
 	tty_wakeup(tty);
 put:
 	tty_kref_put(tty);
 }
 /*
  * Function ircomm_tty_write (tty, buf, count)
  *
  *    This routine is called by the kernel to write a series of characters
  *    to the tty device. The characters may come from user space or kernel
  *    space. This routine will return the number of characters actually
  *    accepted for writing. This routine is mandatory.
  */
 static int ircomm_tty_write(struct tty_struct *tty,
 			    const unsigned char *buf, int count)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	unsigned long flags;
 	struct sk_buff *skb;
 	int tailroom = 0;
 	int len = 0;
 	int size;
 	pr_debug("%s(), count=%d, hw_stopped=%d\n", __func__ , count,
 		 tty->hw_stopped);
 	IRDA_ASSERT(self != NULL, return -1;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 	/* We may receive packets from the TTY even before we have finished
 	 * our setup. Not cool.
 	 * The problem is that we don't know the final header and data size
 	 * to create the proper skb, so any skb we would create would have
 	 * bogus header and data size, so need care.
 	 * We use a bogus header size to safely detect this condition.
 	 * Another problem is that hw_stopped was set to 0 way before it
 	 * should be, so we would drop this skb. It should now be fixed.
 	 * One option is to not accept data until we are properly setup.
 	 * But, I suspect that when it happens, the ppp line discipline
 	 * just "drops" the data, which might screw up connect scripts.
 	 * The second option is to create a "safe skb", with large header
 	 * and small size (see ircomm_tty_open() for values).
 	 * We just need to make sure that when the real values get filled,
 	 * we don't mess up the original "safe skb" (see tx_data_size).
 	 * Jean II */
 	if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED) {
 		pr_debug("%s() : not initialised\n", __func__);
 #ifdef IRCOMM_NO_TX_BEFORE_INIT
 		/* We didn't consume anything, TTY will retry */
 		return 0;
 #endif
 	}
 	if (count < 1)
 		return 0;
 	/* Protect our manipulation of self->tx_skb and related */
 	spin_lock_irqsave(&self->spinlock, flags);
 	/* Fetch current transmit buffer */
 	skb = self->tx_skb;
 	/*
 	 * Send out all the data we get, possibly as multiple fragmented
 	 * frames, but this will only happen if the data is larger than the
 	 * max data size. The normal case however is just the opposite, and
 	 * this function may be called multiple times, and will then actually
 	 * defragment the data and send it out as one packet as soon as
 	 * possible, but at a safer point in time
 	 */
 	while (count) {
 		size = count;
 		/* Adjust data size to the max data size */
 		if (size > self->max_data_size)
 			size = self->max_data_size;
 		/*
 		 * Do we already have a buffer ready for transmit, or do
 		 * we need to allocate a new frame
 		 */
 		if (skb) {
 			/*
 			 * Any room for more data at the end of the current
 			 * transmit buffer? Cannot use skb_tailroom, since
 			 * dev_alloc_skb gives us a larger skb than we
 			 * requested
 			 * Note : use tx_data_size, because max_data_size
 			 * may have changed and we don't want to overwrite
 			 * the skb. - Jean II
 			 */
 			if ((tailroom = (self->tx_data_size - skb->len)) > 0) {
 				/* Adjust data to tailroom */
 				if (size > tailroom)
 					size = tailroom;
 			} else {
 				/*
 				 * Current transmit frame is full, so break
 				 * out, so we can send it as soon as possible
 				 */
 				break;
 			}
 		} else {
 			/* Prepare a full sized frame */
 			skb = alloc_skb(self->max_data_size+
 					self->max_header_size,
 					GFP_ATOMIC);
 			if (!skb) {
 				spin_unlock_irqrestore(&self->spinlock, flags);
 				return -ENOBUFS;
 			}
 			skb_reserve(skb, self->max_header_size);
 			self->tx_skb = skb;
 			/* Remember skb size because max_data_size may
 			 * change later on - Jean II */
 			self->tx_data_size = self->max_data_size;
 		}
 		/* Copy data */
 		memcpy(skb_put(skb,size), buf + len, size);
 		count -= size;
 		len += size;
 	}
 	spin_unlock_irqrestore(&self->spinlock, flags);
 	/*
 	 * Schedule a new thread which will transmit the frame as soon
 	 * as possible, but at a safe point in time. We do this so the
 	 * "user" can give us data multiple times, as PPP does (because of
 	 * its 256 byte tx buffer). We will then defragment and send out
 	 * all this data as one single packet.
 	 */
 	schedule_work(&self->tqueue);
 	return len;
 }
 /*
  * Function ircomm_tty_write_room (tty)
  *
  *    This routine returns the numbers of characters the tty driver will
  *    accept for queuing to be written. This number is subject to change as
  *    output buffers get emptied, or if the output flow control is acted.
  */
 static int ircomm_tty_write_room(struct tty_struct *tty)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	unsigned long flags;
 	int ret;
 	IRDA_ASSERT(self != NULL, return -1;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 #ifdef IRCOMM_NO_TX_BEFORE_INIT
 	/* max_header_size tells us if the channel is initialised or not. */
 	if (self->max_header_size == IRCOMM_TTY_HDR_UNINITIALISED)
 		/* Don't bother us yet */
 		return 0;
 #endif
 	/* Check if we are allowed to transmit any data.
 	 * hw_stopped is the regular flow control.
 	 * Jean II */
 	if (tty->hw_stopped)
 		ret = 0;
 	else {
 		spin_lock_irqsave(&self->spinlock, flags);
 		if (self->tx_skb)
 			ret = self->tx_data_size - self->tx_skb->len;
 		else
 			ret = self->max_data_size;
 		spin_unlock_irqrestore(&self->spinlock, flags);
 	}
 	pr_debug("%s(), ret=%d\n", __func__ , ret);
 	return ret;
 }
 /*
  * Function ircomm_tty_wait_until_sent (tty, timeout)
  *
  *    This routine waits until the device has written out all of the
  *    characters in its transmitter FIFO.
  */
 static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	unsigned long orig_jiffies, poll_time;
 	unsigned long flags;
 	IRDA_ASSERT(self != NULL, return;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
 	orig_jiffies = jiffies;
 	/* Set poll time to 200 ms */
-	poll_time = IRDA_MIN(timeout, msecs_to_jiffies(200));
+	poll_time = msecs_to_jiffies(200);
+	if (timeout)
+		poll_time = min_t(unsigned long, timeout, poll_time);
 	spin_lock_irqsave(&self->spinlock, flags);
 	while (self->tx_skb && self->tx_skb->len) {
 		spin_unlock_irqrestore(&self->spinlock, flags);
 		schedule_timeout_interruptible(poll_time);
 		spin_lock_irqsave(&self->spinlock, flags);
 		if (signal_pending(current))
 			break;
 		if (timeout && time_after(jiffies, orig_jiffies + timeout))
 			break;
 	}
 	spin_unlock_irqrestore(&self->spinlock, flags);
 	__set_current_state(TASK_RUNNING);
 }
 /*
  * Function ircomm_tty_throttle (tty)
  *
  *    This routine notifies the tty driver that input buffers for the line
  *    discipline are close to full, and it should somehow signal that no
  *    more characters should be sent to the tty.
  */
 static void ircomm_tty_throttle(struct tty_struct *tty)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	IRDA_ASSERT(self != NULL, return;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
 	/* Software flow control? */
 	if (I_IXOFF(tty))
 		ircomm_tty_send_xchar(tty, STOP_CHAR(tty));
 	/* Hardware flow control? */
 	if (tty->termios.c_cflag & CRTSCTS) {
 		self->settings.dte &= ~IRCOMM_RTS;
 		self->settings.dte |= IRCOMM_DELTA_RTS;
 		ircomm_param_request(self, IRCOMM_DTE, TRUE);
 	}
 	ircomm_flow_request(self->ircomm, FLOW_STOP);
 }
 /*
  * Function ircomm_tty_unthrottle (tty)
  *
  *    This routine notifies the tty drivers that it should signals that
  *    characters can now be sent to the tty without fear of overrunning the
  *    input buffers of the line disciplines.
  */
 static void ircomm_tty_unthrottle(struct tty_struct *tty)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	IRDA_ASSERT(self != NULL, return;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
 	/* Using software flow control? */
 	if (I_IXOFF(tty)) {
 		ircomm_tty_send_xchar(tty, START_CHAR(tty));
 	}
 	/* Using hardware flow control? */
 	if (tty->termios.c_cflag & CRTSCTS) {
 		self->settings.dte |= (IRCOMM_RTS|IRCOMM_DELTA_RTS);
 		ircomm_param_request(self, IRCOMM_DTE, TRUE);
 		pr_debug("%s(), FLOW_START\n", __func__);
 	}
 	ircomm_flow_request(self->ircomm, FLOW_START);
 }
 /*
  * Function ircomm_tty_chars_in_buffer (tty)
  *
  *    Indicates if there are any data in the buffer
  *
  */
 static int ircomm_tty_chars_in_buffer(struct tty_struct *tty)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	unsigned long flags;
 	int len = 0;
 	IRDA_ASSERT(self != NULL, return -1;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 	spin_lock_irqsave(&self->spinlock, flags);
 	if (self->tx_skb)
 		len = self->tx_skb->len;
 	spin_unlock_irqrestore(&self->spinlock, flags);
 	return len;
 }
 static void ircomm_tty_shutdown(struct ircomm_tty_cb *self)
 {
 	unsigned long flags;
 	IRDA_ASSERT(self != NULL, return;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
 	if (!test_and_clear_bit(ASYNCB_INITIALIZED, &self->port.flags))
 		return;
 	ircomm_tty_detach_cable(self);
 	spin_lock_irqsave(&self->spinlock, flags);
 	del_timer(&self->watchdog_timer);
 	/* Free parameter buffer */
 	if (self->ctrl_skb) {
 		dev_kfree_skb(self->ctrl_skb);
 		self->ctrl_skb = NULL;
 	}
 	/* Free transmit buffer */
 	if (self->tx_skb) {
 		dev_kfree_skb(self->tx_skb);
 		self->tx_skb = NULL;
 	}
 	if (self->ircomm) {
 		ircomm_close(self->ircomm);
 		self->ircomm = NULL;
 	}
 	spin_unlock_irqrestore(&self->spinlock, flags);
 }
 /*
  * Function ircomm_tty_hangup (tty)
  *
  *    This routine notifies the tty driver that it should hangup the tty
  *    device.
  *
  */
 static void ircomm_tty_hangup(struct tty_struct *tty)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	struct tty_port *port = &self->port;
 	unsigned long	flags;
 	IRDA_ASSERT(self != NULL, return;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
 	/* ircomm_tty_flush_buffer(tty); */
 	ircomm_tty_shutdown(self);
 	spin_lock_irqsave(&port->lock, flags);
 	port->flags &= ~ASYNC_NORMAL_ACTIVE;
 	if (port->tty) {
 		set_bit(TTY_IO_ERROR, &port->tty->flags);
 		tty_kref_put(port->tty);
 	}
 	port->tty = NULL;
 	port->count = 0;
 	spin_unlock_irqrestore(&port->lock, flags);
 	wake_up_interruptible(&port->open_wait);
 }
 /*
  * Function ircomm_tty_send_xchar (tty, ch)
  *
  *    This routine is used to send a high-priority XON/XOFF character to
  *    the device.
  */
 static void ircomm_tty_send_xchar(struct tty_struct *tty, char ch)
 {
 	pr_debug("%s(), not impl\n", __func__);
 }
 /*
  * Function ircomm_tty_start (tty)
  *
  *    This routine notifies the tty driver that it resume sending
  *    characters to the tty device.
  */
 void ircomm_tty_start(struct tty_struct *tty)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	ircomm_flow_request(self->ircomm, FLOW_START);
 }
 /*
  * Function ircomm_tty_stop (tty)
  *
  *     This routine notifies the tty driver that it should stop outputting
  *     characters to the tty device.
  */
 static void ircomm_tty_stop(struct tty_struct *tty)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) tty->driver_data;
 	IRDA_ASSERT(self != NULL, return;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
 	ircomm_flow_request(self->ircomm, FLOW_STOP);
 }
 /*
  * Function ircomm_check_modem_status (self)
  *
  *    Check for any changes in the DCE's line settings. This function should
  *    be called whenever the dce parameter settings changes, to update the
  *    flow control settings and other things
  */
 void ircomm_tty_check_modem_status(struct ircomm_tty_cb *self)
 {
 	struct tty_struct *tty;
 	int status;
 	IRDA_ASSERT(self != NULL, return;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
 	tty = tty_port_tty_get(&self->port);
 	status = self->settings.dce;
 	if (status & IRCOMM_DCE_DELTA_ANY) {
 		/*wake_up_interruptible(&self->delta_msr_wait);*/
 	}
 	if ((self->port.flags & ASYNC_CHECK_CD) && (status & IRCOMM_DELTA_CD)) {
 		pr_debug("%s(), ircomm%d CD now %s...\n", __func__ , self->line,
 			 (status & IRCOMM_CD) ? "on" : "off");
 		if (status & IRCOMM_CD) {
 			wake_up_interruptible(&self->port.open_wait);
 		} else {
 			pr_debug("%s(), Doing serial hangup..\n", __func__);
 			if (tty)
 				tty_hangup(tty);
 			/* Hangup will remote the tty, so better break out */
 			goto put;
 		}
 	}
 	if (tty && tty_port_cts_enabled(&self->port)) {
 		if (tty->hw_stopped) {
 			if (status & IRCOMM_CTS) {
 				pr_debug("%s(), CTS tx start...\n", __func__);
 				tty->hw_stopped = 0;
 				/* Wake up processes blocked on open */
 				wake_up_interruptible(&self->port.open_wait);
 				schedule_work(&self->tqueue);
 				goto put;
 			}
 		} else {
 			if (!(status & IRCOMM_CTS)) {
 				pr_debug("%s(), CTS tx stop...\n", __func__);
 				tty->hw_stopped = 1;
 			}
 		}
 	}
 put:
 	tty_kref_put(tty);
 }
 /*
  * Function ircomm_tty_data_indication (instance, sap, skb)
  *
  *    Handle incoming data, and deliver it to the line discipline
  *
  */
 static int ircomm_tty_data_indication(void *instance, void *sap,
 				      struct sk_buff *skb)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 	struct tty_struct *tty;
 	IRDA_ASSERT(self != NULL, return -1;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 	IRDA_ASSERT(skb != NULL, return -1;);
 	tty = tty_port_tty_get(&self->port);
 	if (!tty) {
 		pr_debug("%s(), no tty!\n", __func__);
 		return 0;
 	}
 	/*
 	 * If we receive data when hardware is stopped then something is wrong.
 	 * We try to poll the peers line settings to check if we are up todate.
 	 * Devices like WinCE can do this, and since they don't send any
 	 * params, we can just as well declare the hardware for running.
 	 */
 	if (tty->hw_stopped && (self->flow == FLOW_START)) {
 		pr_debug("%s(), polling for line settings!\n", __func__);
 		ircomm_param_request(self, IRCOMM_POLL, TRUE);
 		/* We can just as well declare the hardware for running */
 		ircomm_tty_send_initial_parameters(self);
 		ircomm_tty_link_established(self);
 	}
 	tty_kref_put(tty);
 	/*
 	 * Use flip buffer functions since the code may be called from interrupt
 	 * context
 	 */
 	tty_insert_flip_string(&self->port, skb->data, skb->len);
 	tty_flip_buffer_push(&self->port);
 	/* No need to kfree_skb - see ircomm_ttp_data_indication() */
 	return 0;
 }
 /*
  * Function ircomm_tty_control_indication (instance, sap, skb)
  *
  *    Parse all incoming parameters (easy!)
  *
  */
 static int ircomm_tty_control_indication(void *instance, void *sap,
 					 struct sk_buff *skb)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 	int clen;
 	IRDA_ASSERT(self != NULL, return -1;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return -1;);
 	IRDA_ASSERT(skb != NULL, return -1;);
 	clen = skb->data[0];
 	irda_param_extract_all(self, skb->data+1, IRDA_MIN(skb->len-1, clen),
 			       &ircomm_param_info);
 	/* No need to kfree_skb - see ircomm_control_indication() */
 	return 0;
 }
 /*
  * Function ircomm_tty_flow_indication (instance, sap, cmd)
  *
  *    This function is called by IrTTP when it wants us to slow down the
  *    transmission of data. We just mark the hardware as stopped, and wait
  *    for IrTTP to notify us that things are OK again.
  */
 static void ircomm_tty_flow_indication(void *instance, void *sap,
 				       LOCAL_FLOW cmd)
 {
 	struct ircomm_tty_cb *self = (struct ircomm_tty_cb *) instance;
 	struct tty_struct *tty;
 	IRDA_ASSERT(self != NULL, return;);
 	IRDA_ASSERT(self->magic == IRCOMM_TTY_MAGIC, return;);
 	tty = tty_port_tty_get(&self->port);
 	switch (cmd) {
 	case FLOW_START:
 		pr_debug("%s(), hw start!\n", __func__);
 		if (tty)
 			tty->hw_stopped = 0;
 		/* ircomm_tty_do_softint will take care of the rest */
 		schedule_work(&self->tqueue);
 		break;
 	default:  /* If we get here, something is very wrong, better stop */
 	case FLOW_STOP:
 		pr_debug("%s(), hw stopped!\n", __func__);
 		if (tty)
 			tty->hw_stopped = 1;
 		break;
 	}
 	tty_kref_put(tty);
 	self->flow = cmd;
 }
 #ifdef CONFIG_PROC_FS
 static void ircomm_tty_line_info(struct ircomm_tty_cb *self, struct seq_file *m)
 {
 	struct tty_struct *tty;
 	char sep;
 	seq_printf(m, "State: %s\n", ircomm_tty_state[self->state]);
 	seq_puts(m, "Service type: ");
 	if (self->service_type & IRCOMM_9_WIRE)
 		seq_puts(m, "9_WIRE");
 	else if (self->service_type & IRCOMM_3_WIRE)
 		seq_puts(m, "3_WIRE");
 	else if (self->service_type & IRCOMM_3_WIRE_RAW)
 		seq_puts(m, "3_WIRE_RAW");
 	else
 		seq_puts(m, "No common service type!\n");
 	seq_putc(m, '\n');
 	seq_printf(m, "Port name: %s\n", self->settings.port_name);
 	seq_printf(m, "DTE status:");
 	sep = ' ';
 	if (self->settings.dte & IRCOMM_RTS) {
 		seq_printf(m, "%cRTS", sep);
 		sep = '|';
 	}
 	if (self->settings.dte & IRCOMM_DTR) {
 		seq_printf(m, "%cDTR", sep);
 		sep = '|';
 	}
 	seq_putc(m, '\n');
 	seq_puts(m, "DCE status:");
 	sep = ' ';
 	if (self->settings.dce & IRCOMM_CTS) {
 		seq_printf(m, "%cCTS", sep);
 		sep = '|';
 	}
 	if (self->settings.dce & IRCOMM_DSR) {
 		seq_printf(m, "%cDSR", sep);
 		sep = '|';
 	}
 	if (self->settings.dce & IRCOMM_CD) {
 		seq_printf(m, "%cCD", sep);
 		sep = '|';
 	}
 	if (self->settings.dce & IRCOMM_RI) {
 		seq_printf(m, "%cRI", sep);
 		sep = '|';
 	}
 	seq_putc(m, '\n');
 	seq_puts(m, "Configuration: ");
 	if (!self->settings.null_modem)
 		seq_puts(m, "DTE <-> DCE\n");
 	else
 		seq_puts(m, "DTE <-> DTE (null modem emulation)\n");
 	seq_printf(m, "Data rate: %d\n", self->settings.data_rate);
 	seq_puts(m, "Flow control:");
 	sep = ' ';
 	if (self->settings.flow_control & IRCOMM_XON_XOFF_IN) {
 		seq_printf(m, "%cXON_XOFF_IN", sep);
 		sep = '|';
 	}
 	if (self->settings.flow_control & IRCOMM_XON_XOFF_OUT) {
 		seq_printf(m, "%cXON_XOFF_OUT", sep);
 		sep = '|';
 	}
 	if (self->settings.flow_control & IRCOMM_RTS_CTS_IN) {
 		seq_printf(m, "%cRTS_CTS_IN", sep);
 		sep = '|';
 	}
 	if (self->settings.flow_control & IRCOMM_RTS_CTS_OUT) {
 		seq_printf(m, "%cRTS_CTS_OUT", sep);
 		sep = '|';
 	}
 	if (self->settings.flow_control & IRCOMM_DSR_DTR_IN) {
 		seq_printf(m, "%cDSR_DTR_IN", sep);
 		sep = '|';
 	}
 	if (self->settings.flow_control & IRCOMM_DSR_DTR_OUT) {
 		seq_printf(m, "%cDSR_DTR_OUT", sep);
 		sep = '|';
 	}
 	if (self->settings.flow_control & IRCOMM_ENQ_ACK_IN) {
 		seq_printf(m, "%cENQ_ACK_IN", sep);
 		sep = '|';
 	}
 	if (self->settings.flow_control & IRCOMM_ENQ_ACK_OUT) {
 		seq_printf(m, "%cENQ_ACK_OUT", sep);
 		sep = '|';
 	}
 	seq_putc(m, '\n');
 	seq_puts(m, "Flags:");
 	sep = ' ';
 	if (tty_port_cts_enabled(&self->port)) {
 		seq_printf(m, "%cASYNC_CTS_FLOW", sep);
 		sep = '|';
 	}
 	if (self->port.flags & ASYNC_CHECK_CD) {
 		seq_printf(m, "%cASYNC_CHECK_CD", sep);
 		sep = '|';
 	}
 	if (self->port.flags & ASYNC_INITIALIZED) {
 		seq_printf(m, "%cASYNC_INITIALIZED", sep);
 		sep = '|';
 	}
 	if (self->port.flags & ASYNC_LOW_LATENCY) {
 		seq_printf(m, "%cASYNC_LOW_LATENCY", sep);
 		sep = '|';
 	}
 	if (self->port.flags & ASYNC_CLOSING) {
 		seq_printf(m, "%cASYNC_CLOSING", sep);
 		sep = '|';
 	}
 	if (self->port.flags & ASYNC_NORMAL_ACTIVE) {
 		seq_printf(m, "%cASYNC_NORMAL_ACTIVE", sep);
 		sep = '|';
 	}
 	seq_putc(m, '\n');
 	seq_printf(m, "Role: %s\n", self->client ? "client" : "server");
 	seq_printf(m, "Open count: %d\n", self->port.count);
 	seq_printf(m, "Max data size: %d\n", self->max_data_size);
 	seq_printf(m, "Max header size: %d\n", self->max_header_size);
 	tty = tty_port_tty_get(&self->port);
 	if (tty) {
 		seq_printf(m, "Hardware: %s\n",
 			       tty->hw_stopped ? "Stopped" : "Running");
 		tty_kref_put(tty);
 	}
 }
 static int ircomm_tty_proc_show(struct seq_file *m, void *v)
 {
 	struct ircomm_tty_cb *self;
 	unsigned long flags;
 	spin_lock_irqsave(&ircomm_tty->hb_spinlock, flags);
 	self = (struct ircomm_tty_cb *) hashbin_get_first(ircomm_tty);
 	while (self != NULL) {
 		if (self->magic != IRCOMM_TTY_MAGIC)
 			break;
 		ircomm_tty_line_info(self, m);
 		self = (struct ircomm_tty_cb *) hashbin_get_next(ircomm_tty);
 	}
 	spin_unlock_irqrestore(&ircomm_tty->hb_spinlock, flags);
 	return 0;
 }
 static int ircomm_tty_proc_open(struct inode *inode, struct file *file)
 {
 	return single_open(file, ircomm_tty_proc_show, NULL);
 }
 static const struct file_operations ircomm_tty_proc_fops = {
 	.owner		= THIS_MODULE,
 	.open		= ircomm_tty_proc_open,
 	.read		= seq_read,
 	.llseek		= seq_lseek,
 	.release	= single_release,
 };
 #endif /* CONFIG_PROC_FS */
 MODULE_AUTHOR("Dag Brattli <dagb@cs.uit.no>");
 MODULE_DESCRIPTION("IrCOMM serial TTY driver");
 MODULE_LICENSE("GPL");
 MODULE_ALIAS_CHARDEV_MAJOR(IRCOMM_TTY_MAJOR);
 module_init(ircomm_tty_init);
 module_exit(ircomm_tty_cleanup);