diff options
| -rw-r--r-- | target/linux/linux-2.4/patches/ar7/000-ar7_support.patch | 6058 |
1 files changed, 0 insertions, 6058 deletions
diff --git a/target/linux/linux-2.4/patches/ar7/000-ar7_support.patch b/target/linux/linux-2.4/patches/ar7/000-ar7_support.patch index c5fe2486e..0c9c0d302 100644 --- a/target/linux/linux-2.4/patches/ar7/000-ar7_support.patch +++ b/target/linux/linux-2.4/patches/ar7/000-ar7_support.patch @@ -5847,6064 +5847,6 @@ diff -urN linux.old/drivers/char/serial.c linux.dev/drivers/char/serial.c cval = cflag & (CSIZE | CSTOPB); #if defined(__powerpc__) || defined(__alpha__) cval >>= 8; -diff -urN linux.old/drivers/char/serial.c.orig linux.dev/drivers/char/serial.c.orig ---- linux.old/drivers/char/serial.c.orig 1970-01-01 01:00:00.000000000 +0100 -+++ linux.dev/drivers/char/serial.c.orig 2005-11-10 01:10:46.051587500 +0100 -@@ -0,0 +1,6054 @@ -+/* -+ * linux/drivers/char/serial.c -+ * -+ * Copyright (C) 1991, 1992 Linus Torvalds -+ * Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, -+ * 1998, 1999 Theodore Ts'o -+ * -+ * Extensively rewritten by Theodore Ts'o, 8/16/92 -- 9/14/92. Now -+ * much more extensible to support other serial cards based on the -+ * 16450/16550A UART's. Added support for the AST FourPort and the -+ * Accent Async board. -+ * -+ * set_serial_info fixed to set the flags, custom divisor, and uart -+ * type fields. Fix suggested by Michael K. Johnson 12/12/92. -+ * -+ * 11/95: TIOCMIWAIT, TIOCGICOUNT by Angelo Haritsis <ah@doc.ic.ac.uk> -+ * -+ * 03/96: Modularised by Angelo Haritsis <ah@doc.ic.ac.uk> -+ * -+ * rs_set_termios fixed to look also for changes of the input -+ * flags INPCK, BRKINT, PARMRK, IGNPAR and IGNBRK. -+ * Bernd Anhäupl 05/17/96. -+ * -+ * 1/97: Extended dumb serial ports are a config option now. -+ * Saves 4k. Michael A. Griffith <grif@acm.org> -+ * -+ * 8/97: Fix bug in rs_set_termios with RTS -+ * Stanislav V. Voronyi <stas@uanet.kharkov.ua> -+ * -+ * 3/98: Change the IRQ detection, use of probe_irq_o*(), -+ * suppress TIOCSERGWILD and TIOCSERSWILD -+ * Etienne Lorrain <etienne.lorrain@ibm.net> -+ * -+ * 4/98: Added changes to support the ARM architecture proposed by -+ * Russell King -+ * -+ * 5/99: Updated to include support for the XR16C850 and ST16C654 -+ * uarts. Stuart MacDonald <stuartm@connecttech.com> -+ * -+ * 8/99: Generalized PCI support added. Theodore Ts'o -+ * -+ * 3/00: Rid circular buffer of redundant xmit_cnt. Fix a -+ * few races on freeing buffers too. -+ * Alan Modra <alan@linuxcare.com> -+ * -+ * 5/00: Support for the RSA-DV II/S card added. -+ * Kiyokazu SUTO <suto@ks-and-ks.ne.jp> -+ * -+ * 6/00: Remove old-style timer, use timer_list -+ * Andrew Morton <andrewm@uow.edu.au> -+ * -+ * 7/00: Support Timedia/Sunix/Exsys PCI cards -+ * -+ * 7/00: fix some returns on failure not using MOD_DEC_USE_COUNT. -+ * Arnaldo Carvalho de Melo <acme@conectiva.com.br> -+ * -+ * 10/00: add in optional software flow control for serial console. -+ * Kanoj Sarcar <kanoj@sgi.com> (Modified by Theodore Ts'o) -+ * -+ * 02/02: Fix for AMD Elan bug in transmit irq routine, by -+ * Christer Weinigel <wingel@hog.ctrl-c.liu.se>, -+ * Robert Schwebel <robert@schwebel.de>, -+ * Juergen Beisert <jbeisert@eurodsn.de>, -+ * Theodore Ts'o <tytso@mit.edu> -+ * -+ * 10/00: Added suport for MIPS Atlas board. -+ * 11/00: Hooks for serial kernel debug port support added. -+ * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, -+ * carstenl@mips.com -+ * Copyright (C) 2000 MIPS Technologies, Inc. All rights reserved. -+ */ -+ -+static char *serial_version = "5.05c"; -+static char *serial_revdate = "2001-07-08"; -+ -+/* -+ * Serial driver configuration section. Here are the various options: -+ * -+ * CONFIG_HUB6 -+ * Enables support for the venerable Bell Technologies -+ * HUB6 card. -+ * -+ * CONFIG_SERIAL_MANY_PORTS -+ * Enables support for ports beyond the standard, stupid -+ * COM 1/2/3/4. -+ * -+ * CONFIG_SERIAL_MULTIPORT -+ * Enables support for special multiport board support. -+ * -+ * CONFIG_SERIAL_SHARE_IRQ -+ * Enables support for multiple serial ports on one IRQ -+ * -+ * CONFIG_SERIAL_DETECT_IRQ -+ * Enable the autodetection of IRQ on standart ports -+ * -+ * SERIAL_PARANOIA_CHECK -+ * Check the magic number for the async_structure where -+ * ever possible. -+ * -+ * CONFIG_SERIAL_ACPI -+ * Enable support for serial console port and serial -+ * debug port as defined by the SPCR and DBGP tables in -+ * ACPI 2.0. -+ */ -+ -+#include <linux/config.h> -+#include <linux/version.h> -+ -+#undef SERIAL_PARANOIA_CHECK -+#define CONFIG_SERIAL_NOPAUSE_IO -+#define SERIAL_DO_RESTART -+ -+#if 0 -+/* These defines are normally controlled by the autoconf.h */ -+#define CONFIG_SERIAL_MANY_PORTS -+#define CONFIG_SERIAL_SHARE_IRQ -+#define CONFIG_SERIAL_DETECT_IRQ -+#define CONFIG_SERIAL_MULTIPORT -+#define CONFIG_HUB6 -+#endif -+ -+#ifdef CONFIG_PCI -+#define ENABLE_SERIAL_PCI -+#ifndef CONFIG_SERIAL_SHARE_IRQ -+#define CONFIG_SERIAL_SHARE_IRQ -+#endif -+#ifndef CONFIG_SERIAL_MANY_PORTS -+#define CONFIG_SERIAL_MANY_PORTS -+#endif -+#endif -+ -+#ifdef CONFIG_SERIAL_ACPI -+#define ENABLE_SERIAL_ACPI -+#endif -+ -+#if defined(CONFIG_ISAPNP)|| (defined(CONFIG_ISAPNP_MODULE) && defined(MODULE)) -+#ifndef ENABLE_SERIAL_PNP -+#define ENABLE_SERIAL_PNP -+#endif -+#endif -+ -+/* Set of debugging defines */ -+ -+#undef SERIAL_DEBUG_INTR -+#undef SERIAL_DEBUG_OPEN -+#undef SERIAL_DEBUG_FLOW -+#undef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT -+#undef SERIAL_DEBUG_PCI -+#undef SERIAL_DEBUG_AUTOCONF -+ -+/* Sanity checks */ -+ -+#ifdef CONFIG_SERIAL_MULTIPORT -+#ifndef CONFIG_SERIAL_SHARE_IRQ -+#define CONFIG_SERIAL_SHARE_IRQ -+#endif -+#endif -+ -+#ifdef CONFIG_HUB6 -+#ifndef CONFIG_SERIAL_MANY_PORTS -+#define CONFIG_SERIAL_MANY_PORTS -+#endif -+#ifndef CONFIG_SERIAL_SHARE_IRQ -+#define CONFIG_SERIAL_SHARE_IRQ -+#endif -+#endif -+ -+#ifdef MODULE -+#undef CONFIG_SERIAL_CONSOLE -+#endif -+ -+#define CONFIG_SERIAL_RSA -+ -+#define RS_STROBE_TIME (10*HZ) -+#define RS_ISR_PASS_LIMIT 256 -+ -+#if defined(__i386__) && (defined(CONFIG_M386) || defined(CONFIG_M486)) -+#define SERIAL_INLINE -+#endif -+ -+/* -+ * End of serial driver configuration section. -+ */ -+ -+#include <linux/module.h> -+ -+#include <linux/types.h> -+#ifdef LOCAL_HEADERS -+#include "serial_local.h" -+#else -+#include <linux/serial.h> -+#include <linux/serialP.h> -+#include <linux/serial_reg.h> -+#include <asm/serial.h> -+#define LOCAL_VERSTRING "" -+#endif -+ -+#include <linux/errno.h> -+#include <linux/signal.h> -+#include <linux/sched.h> -+#include <linux/timer.h> -+#include <linux/interrupt.h> -+#include <linux/tty.h> -+#include <linux/tty_flip.h> -+#include <linux/major.h> -+#include <linux/string.h> -+#include <linux/fcntl.h> -+#include <linux/ptrace.h> -+#include <linux/ioport.h> -+#include <linux/mm.h> -+#include <linux/slab.h> -+#if (LINUX_VERSION_CODE >= 131343) -+#include <linux/init.h> -+#endif -+#if (LINUX_VERSION_CODE >= 131336) -+#include <asm/uaccess.h> -+#endif -+#include <linux/delay.h> -+#ifdef CONFIG_SERIAL_CONSOLE -+#include <linux/console.h> -+#endif -+#ifdef ENABLE_SERIAL_PCI -+#include <linux/pci.h> -+#endif -+#ifdef ENABLE_SERIAL_PNP -+#include <linux/isapnp.h> -+#endif -+#ifdef CONFIG_MAGIC_SYSRQ -+#include <linux/sysrq.h> -+#endif -+ -+/* -+ * All of the compatibilty code so we can compile serial.c against -+ * older kernels is hidden in serial_compat.h -+ */ -+#if defined(LOCAL_HEADERS) || (LINUX_VERSION_CODE < 0x020317) /* 2.3.23 */ -+#include "serial_compat.h" -+#endif -+ -+#include <asm/system.h> -+#include <asm/io.h> -+#include <asm/irq.h> -+#include <asm/bitops.h> -+ -+#if defined(CONFIG_MAC_SERIAL) -+#define SERIAL_DEV_OFFSET ((_machine == _MACH_prep || _machine == _MACH_chrp) ? 0 : 2) -+#else -+#define SERIAL_DEV_OFFSET 0 -+#endif -+ -+#ifdef SERIAL_INLINE -+#define _INLINE_ inline -+#else -+#define _INLINE_ -+#endif -+ -+static char *serial_name = "Serial driver"; -+ -+static DECLARE_TASK_QUEUE(tq_serial); -+ -+static struct tty_driver serial_driver, callout_driver; -+static int serial_refcount; -+ -+static struct timer_list serial_timer; -+ -+/* serial subtype definitions */ -+#ifndef SERIAL_TYPE_NORMAL -+#define SERIAL_TYPE_NORMAL 1 -+#define SERIAL_TYPE_CALLOUT 2 -+#endif -+ -+/* number of characters left in xmit buffer before we ask for more */ -+#define WAKEUP_CHARS 256 -+ -+/* -+ * IRQ_timeout - How long the timeout should be for each IRQ -+ * should be after the IRQ has been active. -+ */ -+ -+static struct async_struct *IRQ_ports[NR_IRQS]; -+#ifdef CONFIG_SERIAL_MULTIPORT -+static struct rs_multiport_struct rs_multiport[NR_IRQS]; -+#endif -+static int IRQ_timeout[NR_IRQS]; -+#ifdef CONFIG_SERIAL_CONSOLE -+static struct console sercons; -+static int lsr_break_flag; -+#endif -+#if defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) -+static unsigned long break_pressed; /* break, really ... */ -+#endif -+ -+static unsigned detect_uart_irq (struct serial_state * state); -+static void autoconfig(struct serial_state * state); -+static void change_speed(struct async_struct *info, struct termios *old); -+static void rs_wait_until_sent(struct tty_struct *tty, int timeout); -+ -+/* -+ * Here we define the default xmit fifo size used for each type of -+ * UART -+ */ -+static struct serial_uart_config uart_config[] = { -+ { "unknown", 1, 0 }, -+ { "8250", 1, 0 }, -+ { "16450", 1, 0 }, -+ { "16550", 1, 0 }, -+ { "16550A", 16, UART_CLEAR_FIFO | UART_USE_FIFO }, -+ { "cirrus", 1, 0 }, /* usurped by cyclades.c */ -+ { "ST16650", 1, UART_CLEAR_FIFO | UART_STARTECH }, -+ { "ST16650V2", 32, UART_CLEAR_FIFO | UART_USE_FIFO | -+ UART_STARTECH }, -+ { "TI16750", 64, UART_CLEAR_FIFO | UART_USE_FIFO}, -+ { "Startech", 1, 0}, /* usurped by cyclades.c */ -+ { "16C950/954", 128, UART_CLEAR_FIFO | UART_USE_FIFO}, -+ { "ST16654", 64, UART_CLEAR_FIFO | UART_USE_FIFO | -+ UART_STARTECH }, -+ { "XR16850", 128, UART_CLEAR_FIFO | UART_USE_FIFO | -+ UART_STARTECH }, -+ { "RSA", 2048, UART_CLEAR_FIFO | UART_USE_FIFO }, -+ { 0, 0} -+}; -+ -+#if defined(CONFIG_SERIAL_RSA) && defined(MODULE) -+ -+#define PORT_RSA_MAX 4 -+static int probe_rsa[PORT_RSA_MAX]; -+static int force_rsa[PORT_RSA_MAX]; -+ -+MODULE_PARM(probe_rsa, "1-" __MODULE_STRING(PORT_RSA_MAX) "i"); -+MODULE_PARM_DESC(probe_rsa, "Probe I/O ports for RSA"); -+MODULE_PARM(force_rsa, "1-" __MODULE_STRING(PORT_RSA_MAX) "i"); -+MODULE_PARM_DESC(force_rsa, "Force I/O ports for RSA"); -+#endif /* CONFIG_SERIAL_RSA */ -+ -+struct serial_state rs_table[RS_TABLE_SIZE] = { -+ SERIAL_PORT_DFNS /* Defined in serial.h */ -+}; -+ -+#define NR_PORTS (sizeof(rs_table)/sizeof(struct serial_state)) -+int serial_nr_ports = NR_PORTS; -+ -+#if (defined(ENABLE_SERIAL_PCI) || defined(ENABLE_SERIAL_PNP)) -+#define NR_PCI_BOARDS 8 -+ -+static struct pci_board_inst serial_pci_board[NR_PCI_BOARDS]; -+ -+#ifndef IS_PCI_REGION_IOPORT -+#define IS_PCI_REGION_IOPORT(dev, r) (pci_resource_flags((dev), (r)) & \ -+ IORESOURCE_IO) -+#endif -+#ifndef IS_PCI_REGION_IOMEM -+#define IS_PCI_REGION_IOMEM(dev, r) (pci_resource_flags((dev), (r)) & \ -+ IORESOURCE_MEM) -+#endif -+#ifndef PCI_IRQ_RESOURCE -+#define PCI_IRQ_RESOURCE(dev, r) ((dev)->irq_resource[r].start) -+#endif -+#ifndef pci_get_subvendor -+#define pci_get_subvendor(dev) ((dev)->subsystem_vendor) -+#define pci_get_subdevice(dev) ((dev)->subsystem_device) -+#endif -+#endif /* ENABLE_SERIAL_PCI || ENABLE_SERIAL_PNP */ -+ -+#ifndef PREPARE_FUNC -+#define PREPARE_FUNC(dev) (dev->prepare) -+#define ACTIVATE_FUNC(dev) (dev->activate) -+#define DEACTIVATE_FUNC(dev) (dev->deactivate) -+#endif -+ -+#define HIGH_BITS_OFFSET ((sizeof(long)-sizeof(int))*8) -+ -+static struct tty_struct *serial_table[NR_PORTS]; -+static struct termios *serial_termios[NR_PORTS]; -+static struct termios *serial_termios_locked[NR_PORTS]; -+ -+ -+#if defined(MODULE) && defined(SERIAL_DEBUG_MCOUNT) -+#define DBG_CNT(s) printk("(%s): [%x] refc=%d, serc=%d, ttyc=%d -> %s\n", \ -+ kdevname(tty->device), (info->flags), serial_refcount,info->count,tty->count,s) -+#else -+#define DBG_CNT(s) -+#endif -+ -+/* -+ * tmp_buf is used as a temporary buffer by serial_write. We need to -+ * lock it in case the copy_from_user blocks while swapping in a page, -+ * and some other program tries to do a serial write at the same time. -+ * Since the lock will only come under contention when the system is -+ * swapping and available memory is low, it makes sense to share one -+ * buffer across all the serial ports, since it significantly saves -+ * memory if large numbers of serial ports are open. -+ */ -+static unsigned char *tmp_buf; -+#ifdef DECLARE_MUTEX -+static DECLARE_MUTEX(tmp_buf_sem); -+#else -+static struct semaphore tmp_buf_sem = MUTEX; -+#endif -+ -+ -+static inline int serial_paranoia_check(struct async_struct *info, -+ kdev_t device, const char *routine) -+{ -+#ifdef SERIAL_PARANOIA_CHECK -+ static const char *badmagic = -+ "Warning: bad magic number for serial struct (%s) in %s\n"; -+ static const char *badinfo = -+ "Warning: null async_struct for (%s) in %s\n"; -+ -+ if (!info) { -+ printk(badinfo, kdevname(device), routine); -+ return 1; -+ } -+ if (info->magic != SERIAL_MAGIC) { -+ printk(badmagic, kdevname(device), routine); -+ return 1; -+ } -+#endif -+ return 0; -+} -+ -+#if defined(CONFIG_MIPS_ATLAS) || defined(CONFIG_MIPS_SEAD) -+ -+#include <asm/mips-boards/atlas.h> -+ -+static _INLINE_ unsigned int serial_in(struct async_struct *info, int offset) -+{ -+ return (*(volatile unsigned int *)(mips_io_port_base + ATLAS_UART_REGS_BASE + offset*8) & 0xff); -+} -+ -+static _INLINE_ void serial_out(struct async_struct *info, int offset, int value) -+{ -+ *(volatile unsigned int *)(mips_io_port_base + ATLAS_UART_REGS_BASE + offset*8) = value; -+} -+ -+#else -+ -+static _INLINE_ unsigned int serial_in(struct async_struct *info, int offset) -+{ -+ switch (info->io_type) { -+#ifdef CONFIG_HUB6 -+ case SERIAL_IO_HUB6: -+ outb(info->hub6 - 1 + offset, info->port); -+ return inb(info->port+1); -+#endif -+ case SERIAL_IO_MEM: -+ return readb((unsigned long) info->iomem_base + -+ (offset<<info->iomem_reg_shift)); -+ default: -+ return inb(info->port + offset); -+ } -+} -+ -+static _INLINE_ void serial_out(struct async_struct *info, int offset, -+ int value) -+{ -+ switch (info->io_type) { -+#ifdef CONFIG_HUB6 -+ case SERIAL_IO_HUB6: -+ outb(info->hub6 - 1 + offset, info->port); -+ outb(value, info->port+1); -+ break; -+#endif -+ case SERIAL_IO_MEM: -+ writeb(value, (unsigned long) info->iomem_base + -+ (offset<<info->iomem_reg_shift)); -+ break; -+ default: -+ outb(value, info->port+offset); -+ } -+} -+#endif -+ -+ -+/* -+ * We used to support using pause I/O for certain machines. We -+ * haven't supported this for a while, but just in case it's badly -+ * needed for certain old 386 machines, I've left these #define's -+ * in.... -+ */ -+#define serial_inp(info, offset) serial_in(info, offset) -+#define serial_outp(info, offset, value) serial_out(info, offset, value) -+ -+ -+/* -+ * For the 16C950 -+ */ -+void serial_icr_write(struct async_struct *info, int offset, int value) -+{ -+ serial_out(info, UART_SCR, offset); -+ serial_out(info, UART_ICR, value); -+} -+ -+unsigned int serial_icr_read(struct async_struct *info, int offset) -+{ -+ int value; -+ -+ serial_icr_write(info, UART_ACR, info->ACR | UART_ACR_ICRRD); -+ serial_out(info, UART_SCR, offset); -+ value = serial_in(info, UART_ICR); -+ serial_icr_write(info, UART_ACR, info->ACR); -+ return value; -+} -+ -+/* -+ * ------------------------------------------------------------ -+ * rs_stop() and rs_start() -+ * -+ * This routines are called before setting or resetting tty->stopped. -+ * They enable or disable transmitter interrupts, as necessary. -+ * ------------------------------------------------------------ -+ */ -+static void rs_stop(struct tty_struct *tty) -+{ -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ unsigned long flags; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_stop")) -+ return; -+ -+ save_flags(flags); cli(); -+ if (info->IER & UART_IER_THRI) { -+ info->IER &= ~UART_IER_THRI; -+ serial_out(info, UART_IER, info->IER); -+ } -+ if (info->state->type == PORT_16C950) { -+ info->ACR |= UART_ACR_TXDIS; -+ serial_icr_write(info, UART_ACR, info->ACR); -+ } -+ restore_flags(flags); -+} -+ -+static void rs_start(struct tty_struct *tty) -+{ -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ unsigned long flags; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_start")) -+ return; -+ -+ save_flags(flags); cli(); -+ if (info->xmit.head != info->xmit.tail -+ && info->xmit.buf -+ && !(info->IER & UART_IER_THRI)) { -+ info->IER |= UART_IER_THRI; -+ serial_out(info, UART_IER, info->IER); -+ } -+ if (info->state->type == PORT_16C950) { -+ info->ACR &= ~UART_ACR_TXDIS; -+ serial_icr_write(info, UART_ACR, info->ACR); -+ } -+ restore_flags(flags); -+} -+ -+/* -+ * ---------------------------------------------------------------------- -+ * -+ * Here starts the interrupt handling routines. All of the following -+ * subroutines are declared as inline and are folded into -+ * rs_interrupt(). They were separated out for readability's sake. -+ * -+ * Note: rs_interrupt() is a "fast" interrupt, which means that it -+ * runs with interrupts turned off. People who may want to modify -+ * rs_interrupt() should try to keep the interrupt handler as fast as -+ * possible. After you are done making modifications, it is not a bad -+ * idea to do: -+ * -+ * gcc -S -DKERNEL -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer serial.c -+ * -+ * and look at the resulting assemble code in serial.s. -+ * -+ * - Ted Ts'o (tytso@mit.edu), 7-Mar-93 -+ * ----------------------------------------------------------------------- -+ */ -+ -+/* -+ * This routine is used by the interrupt handler to schedule -+ * processing in the software interrupt portion of the driver. -+ */ -+static _INLINE_ void rs_sched_event(struct async_struct *info, -+ int event) -+{ -+ info->event |= 1 << event; -+ queue_task(&info->tqueue, &tq_serial); -+ mark_bh(SERIAL_BH); -+} -+ -+static _INLINE_ void receive_chars(struct async_struct *info, -+ int *status, struct pt_regs * regs) -+{ -+ struct tty_struct *tty = info->tty; -+ unsigned char ch; -+ struct async_icount *icount; -+ int max_count = 256; -+ -+ icount = &info->state->icount; -+ do { -+ if (tty->flip.count >= TTY_FLIPBUF_SIZE) { -+ tty->flip.tqueue.routine((void *) tty); -+ if (tty->flip.count >= TTY_FLIPBUF_SIZE) { -+ /* no room in flip buffer, discard rx FIFO contents to clear IRQ -+ * *FIXME* Hardware with auto flow control -+ * would benefit from leaving the data in the FIFO and -+ * disabling the rx IRQ until space becomes available. -+ */ -+ do { -+ serial_inp(info, UART_RX); -+ icount->overrun++; -+ *status = serial_inp(info, UART_LSR); -+ } while ((*status & UART_LSR_DR) && (max_count-- > 0)); -+ return; // if TTY_DONT_FLIP is set -+ } -+ } -+ ch = serial_inp(info, UART_RX); -+ *tty->flip.char_buf_ptr = ch; -+ icount->rx++; -+ -+#ifdef SERIAL_DEBUG_INTR -+ printk("DR%02x:%02x...", ch, *status); -+#endif -+ *tty->flip.flag_buf_ptr = 0; -+ if (*status & (UART_LSR_BI | UART_LSR_PE | -+ UART_LSR_FE | UART_LSR_OE)) { -+ /* -+ * For statistics only -+ */ -+ if (*status & UART_LSR_BI) { -+ *status &= ~(UART_LSR_FE | UART_LSR_PE); -+ 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 defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) -+ if (info->line == sercons.index) { -+ if (!break_pressed) { -+ break_pressed = jiffies; -+ goto ignore_char; -+ } -+ break_pressed = 0; -+ } -+#endif -+ if (info->flags & ASYNC_SAK) -+ do_SAK(tty); -+ } else if (*status & UART_LSR_PE) -+ icount->parity++; -+ else if (*status & UART_LSR_FE) -+ icount->frame++; -+ if (*status & UART_LSR_OE) -+ icount->overrun++; -+ -+ /* -+ * Mask off conditions which should be ignored. -+ */ -+ *status &= info->read_status_mask; -+ -+#ifdef CONFIG_SERIAL_CONSOLE -+ if (info->line == sercons.index) { -+ /* Recover the break flag from console xmit */ -+ *status |= lsr_break_flag; -+ lsr_break_flag = 0; -+ } -+#endif -+ if (*status & (UART_LSR_BI)) { -+#ifdef SERIAL_DEBUG_INTR -+ printk("handling break...."); -+#endif -+ *tty->flip.flag_buf_ptr = TTY_BREAK; -+ } else if (*status & UART_LSR_PE) -+ *tty->flip.flag_buf_ptr = TTY_PARITY; -+ else if (*status & UART_LSR_FE) -+ *tty->flip.flag_buf_ptr = TTY_FRAME; -+ } -+#if defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) -+ if (break_pressed && info->line == sercons.index) { -+ if (ch != 0 && -+ time_before(jiffies, break_pressed + HZ*5)) { -+ handle_sysrq(ch, regs, NULL, NULL); -+ break_pressed = 0; -+ goto ignore_char; -+ } -+ break_pressed = 0; -+ } -+#endif -+ if ((*status & info->ignore_status_mask) == 0) { -+ tty->flip.flag_buf_ptr++; -+ tty->flip.char_buf_ptr++; -+ tty->flip.count++; -+ } -+ if ((*status & UART_LSR_OE) && -+ (tty->flip.count < TTY_FLIPBUF_SIZE)) { -+ /* -+ * Overrun is special, since it's reported -+ * immediately, and doesn't affect the current -+ * character -+ */ -+ *tty->flip.flag_buf_ptr = TTY_OVERRUN; -+ tty->flip.count++; -+ tty->flip.flag_buf_ptr++; -+ tty->flip.char_buf_ptr++; -+ } -+#if defined(CONFIG_SERIAL_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) -+ ignore_char: -+#endif -+ *status = serial_inp(info, UART_LSR); -+ } while ((*status & UART_LSR_DR) && (max_count-- > 0)); -+#if (LINUX_VERSION_CODE > 131394) /* 2.1.66 */ -+ tty_flip_buffer_push(tty); -+#else -+ queue_task_irq_off(&tty->flip.tqueue, &tq_timer); -+#endif -+} -+ -+static _INLINE_ void transmit_chars(struct async_struct *info, int *intr_done) -+{ -+ int count; -+ -+ if (info->x_char) { -+ serial_outp(info, UART_TX, info->x_char); -+ info->state->icount.tx++; -+ info->x_char = 0; -+ if (intr_done) -+ *intr_done = 0; -+ return; -+ } -+ if (info->xmit.head == info->xmit.tail -+ || info->tty->stopped -+ || info->tty->hw_stopped) { -+ info->IER &= ~UART_IER_THRI; -+ serial_out(info, UART_IER, info->IER); -+ return; -+ } -+ -+ count = info->xmit_fifo_size; -+ do { -+ serial_out(info, UART_TX, info->xmit.buf[info->xmit.tail]); -+ info->xmit.tail = (info->xmit.tail + 1) & (SERIAL_XMIT_SIZE-1); -+ info->state->icount.tx++; -+ if (info->xmit.head == info->xmit.tail) -+ break; -+ } while (--count > 0); -+ -+ if (CIRC_CNT(info->xmit.head, -+ info->xmit.tail, -+ SERIAL_XMIT_SIZE) < WAKEUP_CHARS) -+ rs_sched_event(info, RS_EVENT_WRITE_WAKEUP); -+ -+#ifdef SERIAL_DEBUG_INTR -+ printk("THRE..."); -+#endif -+ if (intr_done) -+ *intr_done = 0; -+ -+ if (info->xmit.head == info->xmit.tail) { -+ info->IER &= ~UART_IER_THRI; -+ serial_out(info, UART_IER, info->IER); -+ } -+} -+ -+static _INLINE_ void check_modem_status(struct async_struct *info) -+{ -+ int status; -+ struct async_icount *icount; -+ -+ status = serial_in(info, UART_MSR); -+ -+ if (status & UART_MSR_ANY_DELTA) { -+ icount = &info->state->icount; -+ /* update input line counters */ -+ if (status & UART_MSR_TERI) -+ icount->rng++; -+ if (status & UART_MSR_DDSR) -+ icount->dsr++; -+ if (status & UART_MSR_DDCD) { -+ icount->dcd++; -+#ifdef CONFIG_HARD_PPS -+ if ((info->flags & ASYNC_HARDPPS_CD) && -+ (status & UART_MSR_DCD)) -+ hardpps(); -+#endif -+ } -+ if (status & UART_MSR_DCTS) -+ icount->cts++; -+ wake_up_interruptible(&info->delta_msr_wait); -+ } -+ -+ if ((info->flags & ASYNC_CHECK_CD) && (status & UART_MSR_DDCD)) { -+#if (defined(SERIAL_DEBUG_OPEN) || defined(SERIAL_DEBUG_INTR)) -+ printk("ttys%d CD now %s...", info->line, -+ (status & UART_MSR_DCD) ? "on" : "off"); -+#endif -+ if (status & UART_MSR_DCD) -+ wake_up_interruptible(&info->open_wait); -+ else if (!((info->flags & ASYNC_CALLOUT_ACTIVE) && -+ (info->flags & ASYNC_CALLOUT_NOHUP))) { -+#ifdef SERIAL_DEBUG_OPEN -+ printk("doing serial hangup..."); -+#endif -+ if (info->tty) -+ tty_hangup(info->tty); -+ } -+ } -+ if (info->flags & ASYNC_CTS_FLOW) { -+ if (info->tty->hw_stopped) { -+ if (status & UART_MSR_CTS) { -+#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW)) -+ printk("CTS tx start..."); -+#endif -+ info->tty->hw_stopped = 0; -+ info->IER |= UART_IER_THRI; -+ serial_out(info, UART_IER, info->IER); -+ rs_sched_event(info, RS_EVENT_WRITE_WAKEUP); -+ return; -+ } -+ } else { -+ if (!(status & UART_MSR_CTS)) { -+#if (defined(SERIAL_DEBUG_INTR) || defined(SERIAL_DEBUG_FLOW)) -+ printk("CTS tx stop..."); -+#endif -+ info->tty->hw_stopped = 1; -+ info->IER &= ~UART_IER_THRI; -+ serial_out(info, UART_IER, info->IER); -+ } -+ } -+ } -+} -+ -+#ifdef CONFIG_SERIAL_SHARE_IRQ -+/* -+ * This is the serial driver's generic interrupt routine -+ */ -+static void rs_interrupt(int irq, void *dev_id, struct pt_regs * regs) -+{ -+ int status, iir; -+ struct async_struct * info; -+ int pass_counter = 0; -+ struct async_struct *end_mark = 0; -+#ifdef CONFIG_SERIAL_MULTIPORT -+ int first_multi = 0; -+ struct rs_multiport_struct *multi; -+#endif -+ -+#ifdef SERIAL_DEBUG_INTR -+ printk("rs_interrupt(%d)...", irq); -+#endif -+ -+ info = IRQ_ports[irq]; -+ if (!info) -+ return; -+ -+#ifdef CONFIG_SERIAL_MULTIPORT -+ multi = &rs_multiport[irq]; -+ if (multi->port_monitor) -+ first_multi = inb(multi->port_monitor); -+#endif -+ -+ do { -+ if (!info->tty || -+ ((iir=serial_in(info, UART_IIR)) & UART_IIR_NO_INT)) { -+ if (!end_mark) -+ end_mark = info; -+ goto next; -+ } -+#ifdef SERIAL_DEBUG_INTR -+ printk("IIR = %x...", serial_in(info, UART_IIR)); -+#endif -+ end_mark = 0; -+ -+ info->last_active = jiffies; -+ -+ status = serial_inp(info, UART_LSR); -+#ifdef SERIAL_DEBUG_INTR -+ printk("status = %x...", status); -+#endif -+ if (status & UART_LSR_DR) -+ receive_chars(info, &status, regs); -+ check_modem_status(info); -+#ifdef CONFIG_MELAN -+ if ((status & UART_LSR_THRE) || -+ /* for buggy ELAN processors */ -+ ((iir & UART_IIR_ID) == UART_IIR_THRI)) -+ transmit_chars(info, 0); -+#else -+ if (status & UART_LSR_THRE) -+ transmit_chars(info, 0); -+#endif -+ -+ next: -+ info = info->next_port; -+ if (!info) { -+ info = IRQ_ports[irq]; -+ if (pass_counter++ > RS_ISR_PASS_LIMIT) { -+#if 0 -+ printk("rs loop break\n"); -+#endif -+ break; /* Prevent infinite loops */ -+ } -+ continue; -+ } -+ } while (end_mark != info); -+#ifdef CONFIG_SERIAL_MULTIPORT -+ if (multi->port_monitor) -+ printk("rs port monitor (normal) irq %d: 0x%x, 0x%x\n", -+ info->state->irq, first_multi, -+ inb(multi->port_monitor)); -+#endif -+#ifdef SERIAL_DEBUG_INTR -+ printk("end.\n"); -+#endif -+} -+#endif /* #ifdef CONFIG_SERIAL_SHARE_IRQ */ -+ -+ -+/* -+ * This is the serial driver's interrupt routine for a single port -+ */ -+static void rs_interrupt_single(int irq, void *dev_id, struct pt_regs * regs) -+{ -+ int status, iir; -+ int pass_counter = 0; -+ struct async_struct * info; -+#ifdef CONFIG_SERIAL_MULTIPORT -+ int first_multi = 0; -+ struct rs_multiport_struct *multi; -+#endif -+ -+#ifdef SERIAL_DEBUG_INTR -+ printk("rs_interrupt_single(%d)...", irq); -+#endif -+ -+ info = IRQ_ports[irq]; -+ if (!info || !info->tty) -+ return; -+ -+#ifdef CONFIG_SERIAL_MULTIPORT -+ multi = &rs_multiport[irq]; -+ if (multi->port_monitor) -+ first_multi = inb(multi->port_monitor); -+#endif -+ -+ iir = serial_in(info, UART_IIR); -+ do { -+ status = serial_inp(info, UART_LSR); -+#ifdef SERIAL_DEBUG_INTR -+ printk("status = %x...", status); -+#endif -+ if (status & UART_LSR_DR) -+ receive_chars(info, &status, regs); -+ check_modem_status(info); -+#ifdef CONFIG_MELAN -+ if ((status & UART_LSR_THRE) || -+ /* For buggy ELAN processors */ -+ ((iir & UART_IIR_ID) == UART_IIR_THRI)) -+ transmit_chars(info, 0); -+#else -+ if (status & UART_LSR_THRE) -+ transmit_chars(info, 0); -+#endif -+ if (pass_counter++ > RS_ISR_PASS_LIMIT) { -+#if SERIAL_DEBUG_INTR -+ printk("rs_single loop break.\n"); -+#endif -+ break; -+ } -+ iir = serial_in(info, UART_IIR); -+#ifdef SERIAL_DEBUG_INTR -+ printk("IIR = %x...", iir); -+#endif -+ } while ((iir & UART_IIR_NO_INT) == 0); -+ info->last_active = jiffies; -+#ifdef CONFIG_SERIAL_MULTIPORT -+ if (multi->port_monitor) -+ printk("rs port monitor (single) irq %d: 0x%x, 0x%x\n", -+ info->state->irq, first_multi, -+ inb(multi->port_monitor)); -+#endif -+#ifdef SERIAL_DEBUG_INTR -+ printk("end.\n"); -+#endif -+} -+ -+#ifdef CONFIG_SERIAL_MULTIPORT -+/* -+ * This is the serial driver's for multiport boards -+ */ -+static void rs_interrupt_multi(int irq, void *dev_id, struct pt_regs * regs) -+{ -+ int status; -+ struct async_struct * info; -+ int pass_counter = 0; -+ int first_multi= 0; -+ struct rs_multiport_struct *multi; -+ -+#ifdef SERIAL_DEBUG_INTR -+ printk("rs_interrupt_multi(%d)...", irq); -+#endif -+ -+ info = IRQ_ports[irq]; -+ if (!info) -+ return; -+ multi = &rs_multiport[irq]; -+ if (!multi->port1) { -+ /* Should never happen */ -+ printk("rs_interrupt_multi: NULL port1!\n"); -+ return; -+ } -+ if (multi->port_monitor) -+ first_multi = inb(multi->port_monitor); -+ -+ while (1) { -+ if (!info->tty || -+ (serial_in(info, UART_IIR) & UART_IIR_NO_INT)) -+ goto next; -+ -+ info->last_active = jiffies; -+ -+ status = serial_inp(info, UART_LSR); -+#ifdef SERIAL_DEBUG_INTR -+ printk("status = %x...", status); -+#endif -+ if (status & UART_LSR_DR) -+ receive_chars(info, &status, regs); -+ check_modem_status(info); -+ if (status & UART_LSR_THRE) -+ transmit_chars(info, 0); -+ -+ next: -+ info = info->next_port; -+ if (info) -+ continue; -+ -+ info = IRQ_ports[irq]; -+ /* -+ * The user was a bonehead, and misconfigured their -+ * multiport info. Rather than lock up the kernel -+ * in an infinite loop, if we loop too many times, -+ * print a message and break out of the loop. -+ */ -+ if (pass_counter++ > RS_ISR_PASS_LIMIT) { -+ printk("Misconfigured multiport serial info " -+ "for irq %d. Breaking out irq loop\n", irq); -+ break; -+ } -+ if (multi->port_monitor) -+ printk("rs port monitor irq %d: 0x%x, 0x%x\n", -+ info->state->irq, first_multi, -+ inb(multi->port_monitor)); -+ if ((inb(multi->port1) & multi->mask1) != multi->match1) -+ continue; -+ if (!multi->port2) -+ break; -+ if ((inb(multi->port2) & multi->mask2) != multi->match2) -+ continue; -+ if (!multi->port3) -+ break; -+ if ((inb(multi->port3) & multi->mask3) != multi->match3) -+ continue; -+ if (!multi->port4) -+ break; -+ if ((inb(multi->port4) & multi->mask4) != multi->match4) -+ continue; -+ break; -+ } -+#ifdef SERIAL_DEBUG_INTR -+ printk("end.\n"); -+#endif -+} -+#endif -+ -+/* -+ * ------------------------------------------------------------------- -+ * Here ends the serial interrupt routines. -+ * ------------------------------------------------------------------- -+ */ -+ -+/* -+ * This routine is used to handle the "bottom half" processing for the -+ * serial driver, known also the "software interrupt" processing. -+ * This processing is done at the kernel interrupt level, after the -+ * rs_interrupt() has returned, BUT WITH INTERRUPTS TURNED ON. This -+ * is where time-consuming activities which can not be done in the -+ * interrupt driver proper are done; the interrupt driver schedules -+ * them using rs_sched_event(), and they get done here. -+ */ -+static void do_serial_bh(void) -+{ -+ run_task_queue(&tq_serial); -+} -+ -+static void do_softint(void *private_) -+{ -+ struct async_struct *info = (struct async_struct *) private_; -+ struct tty_struct *tty; -+ -+ tty = info->tty; -+ if (!tty) -+ return; -+ -+ if (test_and_clear_bit(RS_EVENT_WRITE_WAKEUP, &info->event)) { -+ tty_wakeup(tty); -+ -+#ifdef SERIAL_HAVE_POLL_WAIT -+ wake_up_interruptible(&tty->poll_wait); -+#endif -+ } -+} -+ -+/* -+ * This subroutine is called when the RS_TIMER goes off. It is used -+ * by the serial driver to handle ports that do not have an interrupt -+ * (irq=0). 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 rs_timer(unsigned long dummy) -+{ -+ static unsigned long last_strobe; -+ struct async_struct *info; -+ unsigned int i; -+ unsigned long flags; -+ -+ if ((jiffies - last_strobe) >= RS_STROBE_TIME) { -+ for (i=0; i < NR_IRQS; i++) { -+ info = IRQ_ports[i]; -+ if (!info) -+ continue; -+ save_flags(flags); cli(); -+#ifdef CONFIG_SERIAL_SHARE_IRQ -+ if (info->next_port) { -+ do { -+ serial_out(info, UART_IER, 0); -+ info->IER |= UART_IER_THRI; -+ serial_out(info, UART_IER, info->IER); -+ info = info->next_port; -+ } while (info); -+#ifdef CONFIG_SERIAL_MULTIPORT -+ if (rs_multiport[i].port1) -+ rs_interrupt_multi(i, NULL, NULL); -+ else -+#endif -+ rs_interrupt(i, NULL, NULL); -+ } else -+#endif /* CONFIG_SERIAL_SHARE_IRQ */ -+ rs_interrupt_single(i, NULL, NULL); -+ restore_flags(flags); -+ } -+ } -+ last_strobe = jiffies; -+ mod_timer(&serial_timer, jiffies + RS_STROBE_TIME); -+ -+ if (IRQ_ports[0]) { -+ save_flags(flags); cli(); -+#ifdef CONFIG_SERIAL_SHARE_IRQ -+ rs_interrupt(0, NULL, NULL); -+#else -+ rs_interrupt_single(0, NULL, NULL); -+#endif -+ restore_flags(flags); -+ -+ mod_timer(&serial_timer, jiffies + IRQ_timeout[0]); -+ } -+} -+ -+/* -+ * --------------------------------------------------------------- -+ * Low level utility subroutines for the serial driver: routines to -+ * figure out the appropriate timeout for an interrupt chain, routines -+ * to initialize and startup a serial port, and routines to shutdown a -+ * serial port. Useful stuff like that. -+ * --------------------------------------------------------------- -+ */ -+ -+/* -+ * This routine figures out the correct timeout for a particular IRQ. -+ * It uses the smallest timeout of all of the serial ports in a -+ * particular interrupt chain. Now only used for IRQ 0.... -+ */ -+static void figure_IRQ_timeout(int irq) -+{ -+ struct async_struct *info; -+ int timeout = 60*HZ; /* 60 seconds === a long time :-) */ -+ -+ info = IRQ_ports[irq]; -+ if (!info) { -+ IRQ_timeout[irq] = 60*HZ; -+ return; -+ } -+ while (info) { -+ if (info->timeout < timeout) -+ timeout = info->timeout; -+ info = info->next_port; -+ } -+ if (!irq) -+ timeout = timeout / 2; -+ IRQ_timeout[irq] = (timeout > 3) ? timeout-2 : 1; -+} -+ -+#ifdef CONFIG_SERIAL_RSA -+/* Attempts to turn on the RSA FIFO. Returns zero on failure */ -+static int enable_rsa(struct async_struct *info) -+{ -+ unsigned char mode; -+ int result; -+ unsigned long flags; -+ -+ save_flags(flags); cli(); -+ mode = serial_inp(info, UART_RSA_MSR); -+ result = mode & UART_RSA_MSR_FIFO; -+ -+ if (!result) { -+ serial_outp(info, UART_RSA_MSR, mode | UART_RSA_MSR_FIFO); -+ mode = serial_inp(info, UART_RSA_MSR); -+ result = mode & UART_RSA_MSR_FIFO; -+ } -+ -+ restore_flags(flags); -+ return result; -+} -+ -+/* Attempts to turn off the RSA FIFO. Returns zero on failure */ -+static int disable_rsa(struct async_struct *info) -+{ -+ unsigned char mode; -+ int result; -+ unsigned long flags; -+ -+ save_flags(flags); cli(); -+ mode = serial_inp(info, UART_RSA_MSR); -+ result = !(mode & UART_RSA_MSR_FIFO); -+ -+ if (!result) { -+ serial_outp(info, UART_RSA_MSR, mode & ~UART_RSA_MSR_FIFO); -+ mode = serial_inp(info, UART_RSA_MSR); -+ result = !(mode & UART_RSA_MSR_FIFO); -+ } -+ -+ restore_flags(flags); -+ return result; -+} -+#endif /* CONFIG_SERIAL_RSA */ -+ -+static int startup(struct async_struct * info) -+{ -+ unsigned long flags; -+ int retval=0; -+ void (*handler)(int, void *, struct pt_regs *); -+ struct serial_state *state= info->state; -+ unsigned long page; -+#ifdef CONFIG_SERIAL_MANY_PORTS -+ unsigned short ICP; -+#endif -+ -+ page = get_zeroed_page(GFP_KERNEL); -+ if (!page) -+ return -ENOMEM; -+ -+ save_flags(flags); cli(); -+ -+ if (info->flags & ASYNC_INITIALIZED) { -+ free_page(page); -+ goto errout; -+ } -+ -+ if (!CONFIGURED_SERIAL_PORT(state) || !state->type) { -+ if (info->tty) -+ set_bit(TTY_IO_ERROR, &info->tty->flags); -+ free_page(page); -+ goto errout; -+ } -+ if (info->xmit.buf) -+ free_page(page); -+ else -+ info->xmit.buf = (unsigned char *) page; -+ -+#ifdef SERIAL_DEBUG_OPEN -+ printk("starting up ttys%d (irq %d)...", info->line, state->irq); -+#endif -+ -+ if (uart_config[state->type].flags & UART_STARTECH) { -+ /* Wake up UART */ -+ serial_outp(info, UART_LCR, 0xBF); -+ serial_outp(info, UART_EFR, UART_EFR_ECB); -+ /* -+ * Turn off LCR == 0xBF so we actually set the IER -+ * register on the XR16C850 -+ */ -+ serial_outp(info, UART_LCR, 0); -+ serial_outp(info, UART_IER, 0); -+ /* -+ * Now reset LCR so we can turn off the ECB bit -+ */ -+ serial_outp(info, UART_LCR, 0xBF); -+ serial_outp(info, UART_EFR, 0); -+ /* -+ * For a XR16C850, we need to set the trigger levels -+ */ -+ if (state->type == PORT_16850) { -+ serial_outp(info, UART_FCTR, UART_FCTR_TRGD | -+ UART_FCTR_RX); -+ serial_outp(info, UART_TRG, UART_TRG_96); -+ serial_outp(info, UART_FCTR, UART_FCTR_TRGD | -+ UART_FCTR_TX); -+ serial_outp(info, UART_TRG, UART_TRG_96); -+ } -+ serial_outp(info, UART_LCR, 0); -+ } -+ -+ if (state->type == PORT_16750) { -+ /* Wake up UART */ -+ serial_outp(info, UART_IER, 0); -+ } -+ -+ if (state->type == PORT_16C950) { -+ /* Wake up and initialize UART */ -+ info->ACR = 0; -+ serial_outp(info, UART_LCR, 0xBF); -+ serial_outp(info, UART_EFR, UART_EFR_ECB); -+ serial_outp(info, UART_IER, 0); -+ serial_outp(info, UART_LCR, 0); -+ serial_icr_write(info, UART_CSR, 0); /* Reset the UART */ -+ serial_outp(info, UART_LCR, 0xBF); -+ serial_outp(info, UART_EFR, UART_EFR_ECB); -+ serial_outp(info, UART_LCR, 0); -+ } -+ -+#ifdef CONFIG_SERIAL_RSA -+ /* -+ * If this is an RSA port, see if we can kick it up to the -+ * higher speed clock. -+ */ -+ if (state->type == PORT_RSA) { -+ if (state->baud_base != SERIAL_RSA_BAUD_BASE && -+ enable_rsa(info)) -+ state->baud_base = SERIAL_RSA_BAUD_BASE; -+ if (state->baud_base == SERIAL_RSA_BAUD_BASE) -+ serial_outp(info, UART_RSA_FRR, 0); -+ } -+#endif -+ -+ /* -+ * Clear the FIFO buffers and disable them -+ * (they will be reenabled in change_speed()) -+ */ -+ if (uart_config[state->type].flags & UART_CLEAR_FIFO) { -+ serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO); -+ serial_outp(info, UART_FCR, (UART_FCR_ENABLE_FIFO | -+ UART_FCR_CLEAR_RCVR | -+ UART_FCR_CLEAR_XMIT)); -+ serial_outp(info, UART_FCR, 0); -+ } -+ -+ /* -+ * Clear the interrupt registers. -+ */ -+ (void) serial_inp(info, UART_LSR); -+ (void) serial_inp(info, UART_RX); -+ (void) serial_inp(info, UART_IIR); -+ (void) serial_inp(info, 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 (!(info->flags & ASYNC_BUGGY_UART) && -+ (serial_inp(info, UART_LSR) == 0xff)) { -+ printk("ttyS%d: LSR safety check engaged!\n", state->line); -+ if (capable(CAP_SYS_ADMIN)) { -+ if (info->tty) -+ set_bit(TTY_IO_ERROR, &info->tty->flags); -+ } else -+ retval = -ENODEV; -+ goto errout; -+ } -+ -+ /* -+ * Allocate the IRQ if necessary -+ */ -+ if (state->irq && (!IRQ_ports[state->irq] || -+ !IRQ_ports[state->irq]->next_port)) { -+ if (IRQ_ports[state->irq]) { -+#ifdef CONFIG_SERIAL_SHARE_IRQ -+ free_irq(state->irq, &IRQ_ports[state->irq]); -+#ifdef CONFIG_SERIAL_MULTIPORT -+ if (rs_multiport[state->irq].port1) -+ handler = rs_interrupt_multi; -+ else -+#endif -+ handler = rs_interrupt; -+#else -+ retval = -EBUSY; -+ goto errout; -+#endif /* CONFIG_SERIAL_SHARE_IRQ */ -+ } else -+ handler = rs_interrupt_single; -+ -+ retval = request_irq(state->irq, handler, SA_SHIRQ, -+ "serial", &IRQ_ports[state->irq]); -+ if (retval) { -+ if (capable(CAP_SYS_ADMIN)) { -+ if (info->tty) -+ set_bit(TTY_IO_ERROR, -+ &info->tty->flags); -+ retval = 0; -+ } -+ goto errout; -+ } -+ } -+ -+ /* -+ * Insert serial port into IRQ chain. -+ */ -+ info->prev_port = 0; -+ info->next_port = IRQ_ports[state->irq]; -+ if (info->next_port) -+ info->next_port->prev_port = info; -+ IRQ_ports[state->irq] = info; -+ figure_IRQ_timeout(state->irq); -+ -+ /* -+ * Now, initialize the UART -+ */ -+ serial_outp(info, UART_LCR, UART_LCR_WLEN8); /* reset DLAB */ -+ -+ info->MCR = 0; -+ if (info->tty->termios->c_cflag & CBAUD) -+ info->MCR = UART_MCR_DTR | UART_MCR_RTS; -+#ifdef CONFIG_SERIAL_MANY_PORTS -+ if (info->flags & ASYNC_FOURPORT) { -+ if (state->irq == 0) -+ info->MCR |= UART_MCR_OUT1; -+ } else -+#endif -+ { -+ if (state->irq != 0) -+ info->MCR |= UART_MCR_OUT2; -+ } -+ info->MCR |= ALPHA_KLUDGE_MCR; /* Don't ask */ -+ serial_outp(info, UART_MCR, info->MCR); -+ -+ /* -+ * Finally, enable interrupts -+ */ -+ info->IER = UART_IER_MSI | UART_IER_RLSI | UART_IER_RDI; -+ serial_outp(info, UART_IER, info->IER); /* enable interrupts */ -+ -+#ifdef CONFIG_SERIAL_MANY_PORTS -+ if (info->flags & ASYNC_FOURPORT) { -+ /* Enable interrupts on the AST Fourport board */ -+ ICP = (info->port & 0xFE0) | 0x01F; -+ outb_p(0x80, ICP); -+ (void) inb_p(ICP); -+ } -+#endif -+ -+ /* -+ * And clear the interrupt registers again for luck. -+ */ -+ (void)serial_inp(info, UART_LSR); -+ (void)serial_inp(info, UART_RX); -+ (void)serial_inp(info, UART_IIR); -+ (void)serial_inp(info, UART_MSR); -+ -+ if (info->tty) -+ clear_bit(TTY_IO_ERROR, &info->tty->flags); -+ info->xmit.head = info->xmit.tail = 0; -+ -+ /* -+ * Set up serial timers... -+ */ -+ mod_timer(&serial_timer, jiffies + 2*HZ/100); -+ -+ /* -+ * Set up the tty->alt_speed kludge -+ */ -+#if (LINUX_VERSION_CODE >= 131394) /* Linux 2.1.66 */ -+ if (info->tty) { -+ if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) -+ info->tty->alt_speed = 57600; -+ if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) -+ info->tty->alt_speed = 115200; -+ if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI) -+ info->tty->alt_speed = 230400; -+ if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP) -+ info->tty->alt_speed = 460800; -+ } -+#endif -+ -+ /* -+ * and set the speed of the serial port -+ */ -+ change_speed(info, 0); -+ -+ info->flags |= ASYNC_INITIALIZED; -+ restore_flags(flags); -+ return 0; -+ -+errout: -+ restore_flags(flags); -+ return retval; -+} -+ -+/* -+ * This routine will shutdown a serial port; interrupts are disabled, and -+ * DTR is dropped if the hangup on close termio flag is on. -+ */ -+static void shutdown(struct async_struct * info) -+{ -+ unsigned long flags; -+ struct serial_state *state; -+ int retval; -+ -+ if (!(info->flags & ASYNC_INITIALIZED)) -+ return; -+ -+ state = info->state; -+ -+#ifdef SERIAL_DEBUG_OPEN -+ printk("Shutting down serial port %d (irq %d)....", info->line, -+ state->irq); -+#endif -+ -+ save_flags(flags); cli(); /* Disable interrupts */ -+ -+ /* -+ * clear delta_msr_wait queue to avoid mem leaks: we may free the irq -+ * here so the queue might never be waken up -+ */ -+ wake_up_interruptible(&info->delta_msr_wait); -+ -+ /* -+ * First unlink the serial port from the IRQ chain... -+ */ -+ if (info->next_port) -+ info->next_port->prev_port = info->prev_port; -+ if (info->prev_port) -+ info->prev_port->next_port = info->next_port; -+ else -+ IRQ_ports[state->irq] = info->next_port; -+ figure_IRQ_timeout(state->irq); -+ -+ /* -+ * Free the IRQ, if necessary -+ */ -+ if (state->irq && (!IRQ_ports[state->irq] || -+ !IRQ_ports[state->irq]->next_port)) { -+ if (IRQ_ports[state->irq]) { -+ free_irq(state->irq, &IRQ_ports[state->irq]); -+ retval = request_irq(state->irq, rs_interrupt_single, -+ SA_SHIRQ, "serial", -+ &IRQ_ports[state->irq]); -+ -+ if (retval) -+ printk("serial shutdown: request_irq: error %d" -+ " Couldn't reacquire IRQ.\n", retval); -+ } else -+ free_irq(state->irq, &IRQ_ports[state->irq]); -+ } -+ -+ if (info->xmit.buf) { -+ unsigned long pg = (unsigned long) info->xmit.buf; -+ info->xmit.buf = 0; -+ free_page(pg); -+ } -+ -+ info->IER = 0; -+ serial_outp(info, UART_IER, 0x00); /* disable all intrs */ -+#ifdef CONFIG_SERIAL_MANY_PORTS -+ if (info->flags & ASYNC_FOURPORT) { -+ /* reset interrupts on the AST Fourport board */ -+ (void) inb((info->port & 0xFE0) | 0x01F); -+ info->MCR |= UART_MCR_OUT1; -+ } else -+#endif -+ info->MCR &= ~UART_MCR_OUT2; -+ info->MCR |= ALPHA_KLUDGE_MCR; /* Don't ask */ -+ -+ /* disable break condition */ -+ serial_out(info, UART_LCR, serial_inp(info, UART_LCR) & ~UART_LCR_SBC); -+ -+ if (!info->tty || (info->tty->termios->c_cflag & HUPCL)) -+ info->MCR &= ~(UART_MCR_DTR|UART_MCR_RTS); -+ serial_outp(info, UART_MCR, info->MCR); -+ -+ /* disable FIFO's */ -+ serial_outp(info, UART_FCR, (UART_FCR_ENABLE_FIFO | -+ UART_FCR_CLEAR_RCVR | -+ UART_FCR_CLEAR_XMIT)); -+ serial_outp(info, UART_FCR, 0); -+ -+#ifdef CONFIG_SERIAL_RSA -+ /* -+ * Reset the RSA board back to 115kbps compat mode. -+ */ -+ if ((state->type == PORT_RSA) && -+ (state->baud_base == SERIAL_RSA_BAUD_BASE && -+ disable_rsa(info))) -+ state->baud_base = SERIAL_RSA_BAUD_BASE_LO; -+#endif -+ -+ -+ (void)serial_in(info, UART_RX); /* read data port to reset things */ -+ -+ if (info->tty) -+ set_bit(TTY_IO_ERROR, &info->tty->flags); -+ -+ if (uart_config[info->state->type].flags & UART_STARTECH) { -+ /* Arrange to enter sleep mode */ -+ serial_outp(info, UART_LCR, 0xBF); -+ serial_outp(info, UART_EFR, UART_EFR_ECB); -+ serial_outp(info, UART_LCR, 0); -+ serial_outp(info, UART_IER, UART_IERX_SLEEP); -+ serial_outp(info, UART_LCR, 0xBF); -+ serial_outp(info, UART_EFR, 0); -+ serial_outp(info, UART_LCR, 0); -+ } -+ if (info->state->type == PORT_16750) { -+ /* Arrange to enter sleep mode */ -+ serial_outp(info, UART_IER, UART_IERX_SLEEP); -+ } -+ info->flags &= ~ASYNC_INITIALIZED; -+ restore_flags(flags); -+} -+ -+#if (LINUX_VERSION_CODE < 131394) /* Linux 2.1.66 */ -+static int baud_table[] = { -+ 0, 50, 75, 110, 134, 150, 200, 300, -+ 600, 1200, 1800, 2400, 4800, 9600, 19200, -+ 38400, 57600, 115200, 230400, 460800, 0 }; -+ -+static int tty_get_baud_rate(struct tty_struct *tty) -+{ -+ struct async_struct * info = (struct async_struct *)tty->driver_data; -+ unsigned int cflag, i; -+ -+ cflag = tty->termios->c_cflag; -+ -+ i = cflag & CBAUD; -+ if (i & CBAUDEX) { -+ i &= ~CBAUDEX; -+ if (i < 1 || i > 2) -+ tty->termios->c_cflag &= ~CBAUDEX; -+ else -+ i += 15; -+ } -+ if (i == 15) { -+ if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) -+ i += 1; -+ if ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) -+ i += 2; -+ } -+ return baud_table[i]; -+} -+#endif -+ -+/* -+ * This routine is called to set the UART divisor registers to match -+ * the specified baud rate for a serial port. -+ */ -+static void change_speed(struct async_struct *info, -+ struct termios *old_termios) -+{ -+ int quot = 0, baud_base, baud; -+ unsigned cflag, cval, fcr = 0; -+ int bits; -+ unsigned long flags; -+ -+ if (!info->tty || !info->tty->termios) -+ return; -+ cflag = info->tty->termios->c_cflag; -+ if (!CONFIGURED_SERIAL_PORT(info)) -+ return; -+ -+ /* byte size and parity */ -+ switch (cflag & CSIZE) { -+ case CS5: cval = 0x00; bits = 7; break; -+ case CS6: cval = 0x01; bits = 8; break; -+ case CS7: cval = 0x02; bits = 9; break; -+ case CS8: cval = 0x03; bits = 10; break; -+ /* Never happens, but GCC is too dumb to figure it out */ -+ default: cval = 0x00; bits = 7; break; -+ } -+ if (cflag & CSTOPB) { -+ cval |= 0x04; -+ bits++; -+ } -+ if (cflag & PARENB) { -+ cval |= UART_LCR_PARITY; -+ bits++; -+ } -+ if (!(cflag & PARODD)) -+ cval |= UART_LCR_EPAR; -+#ifdef CMSPAR -+ if (cflag & CMSPAR) -+ cval |= UART_LCR_SPAR; -+#endif -+ -+ /* Determine divisor based on baud rate */ -+ baud = tty_get_baud_rate(info->tty); -+ if (!baud) -+ baud = 9600; /* B0 transition handled in rs_set_termios */ -+#ifdef CONFIG_SERIAL_RSA -+ if ((info->state->type == PORT_RSA) && -+ (info->state->baud_base != SERIAL_RSA_BAUD_BASE) && -+ enable_rsa(info)) -+ info->state->baud_base = SERIAL_RSA_BAUD_BASE; -+#endif -+ baud_base = info->state->baud_base; -+ if (info->state->type == PORT_16C950) { -+ if (baud <= baud_base) -+ serial_icr_write(info, UART_TCR, 0); -+ else if (baud <= 2*baud_base) { -+ serial_icr_write(info, UART_TCR, 0x8); -+ baud_base = baud_base * 2; -+ } else if (baud <= 4*baud_base) { -+ serial_icr_write(info, UART_TCR, 0x4); -+ baud_base = baud_base * 4; -+ } else -+ serial_icr_write(info, UART_TCR, 0); -+ } -+ if (baud == 38400 && -+ ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) -+ quot = info->state->custom_divisor; -+ else { -+ if (baud == 134) -+ /* Special case since 134 is really 134.5 */ -+ quot = (2*baud_base / 269); -+ else if (baud) -+ quot = baud_base / baud; -+ } -+ /* If the quotient is zero refuse the change */ -+ if (!quot && old_termios) { -+ info->tty->termios->c_cflag &= ~CBAUD; -+ info->tty->termios->c_cflag |= (old_termios->c_cflag & CBAUD); -+ baud = tty_get_baud_rate(info->tty); -+ if (!baud) -+ baud = 9600; -+ if (baud == 38400 && -+ ((info->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST)) -+ quot = info->state->custom_divisor; -+ else { -+ if (baud == 134) -+ /* Special case since 134 is really 134.5 */ -+ quot = (2*baud_base / 269); -+ else if (baud) -+ quot = baud_base / baud; -+ } -+ } -+ /* As a last resort, if the quotient is zero, default to 9600 bps */ -+ if (!quot) -+ quot = baud_base / 9600; -+ /* -+ * Work around a bug in the Oxford Semiconductor 952 rev B -+ * chip which causes it to seriously miscalculate baud rates -+ * when DLL is 0. -+ */ -+ if (((quot & 0xFF) == 0) && (info->state->type == PORT_16C950) && -+ (info->state->revision == 0x5201)) -+ quot++; -+ -+ info->quot = quot; -+ info->timeout = ((info->xmit_fifo_size*HZ*bits*quot) / baud_base); -+ info->timeout += HZ/50; /* Add .02 seconds of slop */ -+ -+ /* Set up FIFO's */ -+ if (uart_config[info->state->type].flags & UART_USE_FIFO) { -+ if ((info->state->baud_base / quot) < 2400) -+ fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_1; -+#ifdef CONFIG_SERIAL_RSA -+ else if (info->state->type == PORT_RSA) -+ fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_14; -+#endif -+ else -+ fcr = UART_FCR_ENABLE_FIFO | UART_FCR_TRIGGER_8; -+ } -+ if (info->state->type == PORT_16750) -+ fcr |= UART_FCR7_64BYTE; -+ -+ /* CTS flow control flag and modem status interrupts */ -+ info->IER &= ~UART_IER_MSI; -+ if (info->flags & ASYNC_HARDPPS_CD) -+ info->IER |= UART_IER_MSI; -+ if (cflag & CRTSCTS) { -+ info->flags |= ASYNC_CTS_FLOW; -+ info->IER |= UART_IER_MSI; -+ } else -+ info->flags &= ~ASYNC_CTS_FLOW; -+ if (cflag & CLOCAL) -+ info->flags &= ~ASYNC_CHECK_CD; -+ else { -+ info->flags |= ASYNC_CHECK_CD; -+ info->IER |= UART_IER_MSI; -+ } -+ serial_out(info, UART_IER, info->IER); -+ -+ /* -+ * Set up parity check flag -+ */ -+#define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK)) -+ -+ info->read_status_mask = UART_LSR_OE | UART_LSR_THRE | UART_LSR_DR; -+ if (I_INPCK(info->tty)) -+ info->read_status_mask |= UART_LSR_FE | UART_LSR_PE; -+ if (I_BRKINT(info->tty) || I_PARMRK(info->tty)) -+ info->read_status_mask |= UART_LSR_BI; -+ -+ /* -+ * Characters to ignore -+ */ -+ info->ignore_status_mask = 0; -+ if (I_IGNPAR(info->tty)) -+ info->ignore_status_mask |= UART_LSR_PE | UART_LSR_FE; -+ if (I_IGNBRK(info->tty)) { -+ info->ignore_status_mask |= UART_LSR_BI; -+ /* -+ * If we're ignore parity and break indicators, ignore -+ * overruns too. (For real raw support). -+ */ -+ if (I_IGNPAR(info->tty)) -+ info->ignore_status_mask |= UART_LSR_OE; -+ } -+ /* -+ * !!! ignore all characters if CREAD is not set -+ */ -+ if ((cflag & CREAD) == 0) -+ info->ignore_status_mask |= UART_LSR_DR; -+ save_flags(flags); cli(); -+ if (uart_config[info->state->type].flags & UART_STARTECH) { -+ serial_outp(info, UART_LCR, 0xBF); -+ serial_outp(info, UART_EFR, -+ (cflag & CRTSCTS) ? UART_EFR_CTS : 0); -+ } -+ serial_outp(info, UART_LCR, cval | UART_LCR_DLAB); /* set DLAB */ -+ serial_outp(info, UART_DLL, quot & 0xff); /* LS of divisor */ -+ serial_outp(info, UART_DLM, quot >> 8); /* MS of divisor */ -+ if (info->state->type == PORT_16750) -+ serial_outp(info, UART_FCR, fcr); /* set fcr */ -+ serial_outp(info, UART_LCR, cval); /* reset DLAB */ -+ info->LCR = cval; /* Save LCR */ -+ if (info->state->type != PORT_16750) { -+ if (fcr & UART_FCR_ENABLE_FIFO) { -+ /* emulated UARTs (Lucent Venus 167x) need two steps */ -+ serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO); -+ } -+ serial_outp(info, UART_FCR, fcr); /* set fcr */ -+ } -+ restore_flags(flags); -+} -+ -+static void rs_put_char(struct tty_struct *tty, unsigned char ch) -+{ -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ unsigned long flags; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_put_char")) -+ return; -+ -+ if (!tty || !info->xmit.buf) -+ return; -+ -+ save_flags(flags); cli(); -+ if (CIRC_SPACE(info->xmit.head, -+ info->xmit.tail, -+ SERIAL_XMIT_SIZE) == 0) { -+ restore_flags(flags); -+ return; -+ } -+ -+ info->xmit.buf[info->xmit.head] = ch; -+ info->xmit.head = (info->xmit.head + 1) & (SERIAL_XMIT_SIZE-1); -+ restore_flags(flags); -+} -+ -+static void rs_flush_chars(struct tty_struct *tty) -+{ -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ unsigned long flags; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_flush_chars")) -+ return; -+ -+ if (info->xmit.head == info->xmit.tail -+ || tty->stopped -+ || tty->hw_stopped -+ || !info->xmit.buf) -+ return; -+ -+ save_flags(flags); cli(); -+ info->IER |= UART_IER_THRI; -+ serial_out(info, UART_IER, info->IER); -+ restore_flags(flags); -+} -+ -+static int rs_write(struct tty_struct * tty, int from_user, -+ const unsigned char *buf, int count) -+{ -+ int c, ret = 0; -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ unsigned long flags; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_write")) -+ return 0; -+ -+ if (!tty || !info->xmit.buf || !tmp_buf) -+ return 0; -+ -+ save_flags(flags); -+ if (from_user) { -+ down(&tmp_buf_sem); -+ while (1) { -+ int c1; -+ c = CIRC_SPACE_TO_END(info->xmit.head, -+ info->xmit.tail, -+ SERIAL_XMIT_SIZE); -+ if (count < c) -+ c = count; -+ if (c <= 0) -+ break; -+ -+ c -= copy_from_user(tmp_buf, buf, c); -+ if (!c) { -+ if (!ret) -+ ret = -EFAULT; -+ break; -+ } -+ cli(); -+ c1 = CIRC_SPACE_TO_END(info->xmit.head, -+ info->xmit.tail, -+ SERIAL_XMIT_SIZE); -+ if (c1 < c) -+ c = c1; -+ memcpy(info->xmit.buf + info->xmit.head, tmp_buf, c); -+ info->xmit.head = ((info->xmit.head + c) & -+ (SERIAL_XMIT_SIZE-1)); -+ restore_flags(flags); -+ buf += c; -+ count -= c; -+ ret += c; -+ } -+ up(&tmp_buf_sem); -+ } else { -+ cli(); -+ while (1) { -+ c = CIRC_SPACE_TO_END(info->xmit.head, -+ info->xmit.tail, -+ SERIAL_XMIT_SIZE); -+ if (count < c) -+ c = count; -+ if (c <= 0) { -+ break; -+ } -+ memcpy(info->xmit.buf + info->xmit.head, buf, c); -+ info->xmit.head = ((info->xmit.head + c) & -+ (SERIAL_XMIT_SIZE-1)); -+ buf += c; -+ count -= c; -+ ret += c; -+ } -+ restore_flags(flags); -+ } -+ if (info->xmit.head != info->xmit.tail -+ && !tty->stopped -+ && !tty->hw_stopped -+ && !(info->IER & UART_IER_THRI)) { -+ info->IER |= UART_IER_THRI; -+ serial_out(info, UART_IER, info->IER); -+ } -+ return ret; -+} -+ -+static int rs_write_room(struct tty_struct *tty) -+{ -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_write_room")) -+ return 0; -+ return CIRC_SPACE(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE); -+} -+ -+static int rs_chars_in_buffer(struct tty_struct *tty) -+{ -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_chars_in_buffer")) -+ return 0; -+ return CIRC_CNT(info->xmit.head, info->xmit.tail, SERIAL_XMIT_SIZE); -+} -+ -+static void rs_flush_buffer(struct tty_struct *tty) -+{ -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ unsigned long flags; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_flush_buffer")) -+ return; -+ save_flags(flags); cli(); -+ info->xmit.head = info->xmit.tail = 0; -+ restore_flags(flags); -+#ifdef SERIAL_HAVE_POLL_WAIT -+ wake_up_interruptible(&tty->poll_wait); -+#endif -+ tty_wakeup(tty); -+} -+ -+/* -+ * This function is used to send a high-priority XON/XOFF character to -+ * the device -+ */ -+static void rs_send_xchar(struct tty_struct *tty, char ch) -+{ -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_send_char")) -+ return; -+ -+ info->x_char = ch; -+ if (ch) { -+ /* Make sure transmit interrupts are on */ -+ info->IER |= UART_IER_THRI; -+ serial_out(info, UART_IER, info->IER); -+ } -+} -+ -+/* -+ * ------------------------------------------------------------ -+ * rs_throttle() -+ * -+ * This routine is called by the upper-layer tty layer to signal that -+ * incoming characters should be throttled. -+ * ------------------------------------------------------------ -+ */ -+static void rs_throttle(struct tty_struct * tty) -+{ -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ unsigned long flags; -+#ifdef SERIAL_DEBUG_THROTTLE -+ char buf[64]; -+ -+ printk("throttle %s: %d....\n", tty_name(tty, buf), -+ tty->ldisc.chars_in_buffer(tty)); -+#endif -+ -+ if (serial_paranoia_check(info, tty->device, "rs_throttle")) -+ return; -+ -+ if (I_IXOFF(tty)) -+ rs_send_xchar(tty, STOP_CHAR(tty)); -+ -+ if (tty->termios->c_cflag & CRTSCTS) -+ info->MCR &= ~UART_MCR_RTS; -+ -+ save_flags(flags); cli(); -+ serial_out(info, UART_MCR, info->MCR); -+ restore_flags(flags); -+} -+ -+static void rs_unthrottle(struct tty_struct * tty) -+{ -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ unsigned long flags; -+#ifdef SERIAL_DEBUG_THROTTLE -+ char buf[64]; -+ -+ printk("unthrottle %s: %d....\n", tty_name(tty, buf), -+ tty->ldisc.chars_in_buffer(tty)); -+#endif -+ -+ if (serial_paranoia_check(info, tty->device, "rs_unthrottle")) -+ return; -+ -+ if (I_IXOFF(tty)) { -+ if (info->x_char) -+ info->x_char = 0; -+ else -+ rs_send_xchar(tty, START_CHAR(tty)); -+ } -+ if (tty->termios->c_cflag & CRTSCTS) -+ info->MCR |= UART_MCR_RTS; -+ save_flags(flags); cli(); -+ serial_out(info, UART_MCR, info->MCR); -+ restore_flags(flags); -+} -+ -+/* -+ * ------------------------------------------------------------ -+ * rs_ioctl() and friends -+ * ------------------------------------------------------------ -+ */ -+ -+static int get_serial_info(struct async_struct * info, -+ struct serial_struct * retinfo) -+{ -+ struct serial_struct tmp; -+ struct serial_state *state = info->state; -+ -+ if (!retinfo) -+ return -EFAULT; -+ memset(&tmp, 0, sizeof(tmp)); -+ tmp.type = state->type; -+ tmp.line = state->line; -+ tmp.port = state->port; -+ if (HIGH_BITS_OFFSET) -+ tmp.port_high = state->port >> HIGH_BITS_OFFSET; -+ else -+ tmp.port_high = 0; -+ tmp.irq = state->irq; -+ tmp.flags = state->flags; -+ tmp.xmit_fifo_size = state->xmit_fifo_size; -+ tmp.baud_base = state->baud_base; -+ tmp.close_delay = state->close_delay; -+ tmp.closing_wait = state->closing_wait; -+ tmp.custom_divisor = state->custom_divisor; -+ tmp.hub6 = state->hub6; -+ tmp.io_type = state->io_type; -+ if (copy_to_user(retinfo,&tmp,sizeof(*retinfo))) -+ return -EFAULT; -+ return 0; -+} -+ -+static int set_serial_info(struct async_struct * info, -+ struct serial_struct * new_info) -+{ -+ struct serial_struct new_serial; -+ struct serial_state old_state, *state; -+ unsigned int i,change_irq,change_port; -+ int retval = 0; -+ unsigned long new_port; -+ -+ if (copy_from_user(&new_serial,new_info,sizeof(new_serial))) -+ return -EFAULT; -+ state = info->state; -+ old_state = *state; -+ -+ new_port = new_serial.port; -+ if (HIGH_BITS_OFFSET) -+ new_port += (unsigned long) new_serial.port_high << HIGH_BITS_OFFSET; -+ -+ change_irq = new_serial.irq != state->irq; -+ change_port = (new_port != ((int) state->port)) || -+ (new_serial.hub6 != state->hub6); -+ -+ if (!capable(CAP_SYS_ADMIN)) { -+ if (change_irq || change_port || -+ (new_serial.baud_base != state->baud_base) || -+ (new_serial.type != state->type) || -+ (new_serial.close_delay != state->close_delay) || -+ (new_serial.xmit_fifo_size != state->xmit_fifo_size) || -+ ((new_serial.flags & ~ASYNC_USR_MASK) != -+ (state->flags & ~ASYNC_USR_MASK))) -+ return -EPERM; -+ state->flags = ((state->flags & ~ASYNC_USR_MASK) | -+ (new_serial.flags & ASYNC_USR_MASK)); -+ info->flags = ((info->flags & ~ASYNC_USR_MASK) | -+ (new_serial.flags & ASYNC_USR_MASK)); -+ state->custom_divisor = new_serial.custom_divisor; -+ goto check_and_exit; -+ } -+ -+ new_serial.irq = irq_cannonicalize(new_serial.irq); -+ -+ if ((new_serial.irq >= NR_IRQS) || (new_serial.irq < 0) || -+ (new_serial.baud_base < 9600)|| (new_serial.type < PORT_UNKNOWN) || -+ (new_serial.type > PORT_MAX) || (new_serial.type == PORT_CIRRUS) || -+ (new_serial.type == PORT_STARTECH)) { -+ return -EINVAL; -+ } -+ -+ if ((new_serial.type != state->type) || -+ (new_serial.xmit_fifo_size <= 0)) -+ new_serial.xmit_fifo_size = -+ uart_config[new_serial.type].dfl_xmit_fifo_size; -+ -+ /* Make sure address is not already in use */ -+ if (new_serial.type) { -+ for (i = 0 ; i < NR_PORTS; i++) -+ if ((state != &rs_table[i]) && -+ (rs_table[i].io_type == SERIAL_IO_PORT) && -+ (rs_table[i].port == new_port) && -+ rs_table[i].type) -+ return -EADDRINUSE; -+ } -+ -+ if ((change_port || change_irq) && (state->count > 1)) -+ return -EBUSY; -+ -+ /* -+ * OK, past this point, all the error checking has been done. -+ * At this point, we start making changes..... -+ */ -+ -+ state->baud_base = new_serial.baud_base; -+ state->flags = ((state->flags & ~ASYNC_FLAGS) | -+ (new_serial.flags & ASYNC_FLAGS)); -+ info->flags = ((state->flags & ~ASYNC_INTERNAL_FLAGS) | -+ (info->flags & ASYNC_INTERNAL_FLAGS)); -+ state->custom_divisor = new_serial.custom_divisor; -+ state->close_delay = new_serial.close_delay * HZ/100; -+ state->closing_wait = new_serial.closing_wait * HZ/100; -+#if (LINUX_VERSION_CODE > 0x20100) -+ info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0; -+#endif -+ info->xmit_fifo_size = state->xmit_fifo_size = -+ new_serial.xmit_fifo_size; -+ -+ if ((state->type != PORT_UNKNOWN) && state->port) { -+#ifdef CONFIG_SERIAL_RSA -+ if (old_state.type == PORT_RSA) -+ release_region(state->port + UART_RSA_BASE, 16); -+ else -+#endif -+ release_region(state->port,8); -+ } -+ state->type = new_serial.type; -+ if (change_port || change_irq) { -+ /* -+ * We need to shutdown the serial port at the old -+ * port/irq combination. -+ */ -+ shutdown(info); -+ state->irq = new_serial.irq; -+ info->port = state->port = new_port; -+ info->hub6 = state->hub6 = new_serial.hub6; -+ if (info->hub6) -+ info->io_type = state->io_type = SERIAL_IO_HUB6; -+ else if (info->io_type == SERIAL_IO_HUB6) -+ info->io_type = state->io_type = SERIAL_IO_PORT; -+ } -+ if ((state->type != PORT_UNKNOWN) && state->port) { -+#ifdef CONFIG_SERIAL_RSA -+ if (state->type == PORT_RSA) -+ request_region(state->port + UART_RSA_BASE, -+ 16, "serial_rsa(set)"); -+ else -+#endif -+ request_region(state->port,8,"serial(set)"); -+ } -+ -+ -+check_and_exit: -+ if ((!state->port && !state->iomem_base) || !state->type) -+ return 0; -+ if (info->flags & ASYNC_INITIALIZED) { -+ if (((old_state.flags & ASYNC_SPD_MASK) != -+ (state->flags & ASYNC_SPD_MASK)) || -+ (old_state.custom_divisor != state->custom_divisor)) { -+#if (LINUX_VERSION_CODE >= 131394) /* Linux 2.1.66 */ -+ if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI) -+ info->tty->alt_speed = 57600; -+ if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI) -+ info->tty->alt_speed = 115200; -+ if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI) -+ info->tty->alt_speed = 230400; -+ if ((state->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP) -+ info->tty->alt_speed = 460800; -+#endif -+ change_speed(info, 0); -+ } -+ } else -+ retval = startup(info); -+ return retval; -+} -+ -+ -+/* -+ * get_lsr_info - get line status register info -+ * -+ * Purpose: Let user call ioctl() to get info when the UART physically -+ * is emptied. On bus types like RS485, the transmitter must -+ * release the bus after transmitting. This must be done when -+ * the transmit shift register is empty, not be done when the -+ * transmit holding register is empty. This functionality -+ * allows an RS485 driver to be written in user space. -+ */ -+static int get_lsr_info(struct async_struct * info, unsigned int *value) -+{ -+ unsigned char status; -+ unsigned int result; -+ unsigned long flags; -+ -+ save_flags(flags); cli(); -+ status = serial_in(info, UART_LSR); -+ restore_flags(flags); -+ result = ((status & UART_LSR_TEMT) ? TIOCSER_TEMT : 0); -+ -+ /* -+ * If we're about to load something into the transmit -+ * register, we'll pretend the transmitter isn't empty to -+ * avoid a race condition (depending on when the transmit -+ * interrupt happens). -+ */ -+ if (info->x_char || -+ ((CIRC_CNT(info->xmit.head, info->xmit.tail, -+ SERIAL_XMIT_SIZE) > 0) && -+ !info->tty->stopped && !info->tty->hw_stopped)) -+ result &= ~TIOCSER_TEMT; -+ -+ if (copy_to_user(value, &result, sizeof(int))) -+ return -EFAULT; -+ return 0; -+} -+ -+ -+static int get_modem_info(struct async_struct * info, unsigned int *value) -+{ -+ unsigned char control, status; -+ unsigned int result; -+ unsigned long flags; -+ -+ control = info->MCR; -+ save_flags(flags); cli(); -+ status = serial_in(info, UART_MSR); -+ restore_flags(flags); -+ result = ((control & UART_MCR_RTS) ? TIOCM_RTS : 0) -+ | ((control & UART_MCR_DTR) ? TIOCM_DTR : 0) -+#ifdef TIOCM_OUT1 -+ | ((control & UART_MCR_OUT1) ? TIOCM_OUT1 : 0) -+ | ((control & UART_MCR_OUT2) ? TIOCM_OUT2 : 0) -+#endif -+ | ((status & UART_MSR_DCD) ? TIOCM_CAR : 0) -+ | ((status & UART_MSR_RI) ? TIOCM_RNG : 0) -+ | ((status & UART_MSR_DSR) ? TIOCM_DSR : 0) -+ | ((status & UART_MSR_CTS) ? TIOCM_CTS : 0); -+ -+ if (copy_to_user(value, &result, sizeof(int))) -+ return -EFAULT; -+ return 0; -+} -+ -+static int set_modem_info(struct async_struct * info, unsigned int cmd, -+ unsigned int *value) -+{ -+ unsigned int arg; -+ unsigned long flags; -+ -+ if (copy_from_user(&arg, value, sizeof(int))) -+ return -EFAULT; -+ -+ switch (cmd) { -+ case TIOCMBIS: -+ if (arg & TIOCM_RTS) -+ info->MCR |= UART_MCR_RTS; -+ if (arg & TIOCM_DTR) -+ info->MCR |= UART_MCR_DTR; -+#ifdef TIOCM_OUT1 -+ if (arg & TIOCM_OUT1) -+ info->MCR |= UART_MCR_OUT1; -+ if (arg & TIOCM_OUT2) -+ info->MCR |= UART_MCR_OUT2; -+#endif -+ if (arg & TIOCM_LOOP) -+ info->MCR |= UART_MCR_LOOP; -+ break; -+ case TIOCMBIC: -+ if (arg & TIOCM_RTS) -+ info->MCR &= ~UART_MCR_RTS; -+ if (arg & TIOCM_DTR) -+ info->MCR &= ~UART_MCR_DTR; -+#ifdef TIOCM_OUT1 -+ if (arg & TIOCM_OUT1) -+ info->MCR &= ~UART_MCR_OUT1; -+ if (arg & TIOCM_OUT2) -+ info->MCR &= ~UART_MCR_OUT2; -+#endif -+ if (arg & TIOCM_LOOP) -+ info->MCR &= ~UART_MCR_LOOP; -+ break; -+ case TIOCMSET: -+ info->MCR = ((info->MCR & ~(UART_MCR_RTS | -+#ifdef TIOCM_OUT1 -+ UART_MCR_OUT1 | -+ UART_MCR_OUT2 | -+#endif -+ UART_MCR_LOOP | -+ UART_MCR_DTR)) -+ | ((arg & TIOCM_RTS) ? UART_MCR_RTS : 0) -+#ifdef TIOCM_OUT1 -+ | ((arg & TIOCM_OUT1) ? UART_MCR_OUT1 : 0) -+ | ((arg & TIOCM_OUT2) ? UART_MCR_OUT2 : 0) -+#endif -+ | ((arg & TIOCM_LOOP) ? UART_MCR_LOOP : 0) -+ | ((arg & TIOCM_DTR) ? UART_MCR_DTR : 0)); -+ break; -+ default: -+ return -EINVAL; -+ } -+ save_flags(flags); cli(); -+ info->MCR |= ALPHA_KLUDGE_MCR; /* Don't ask */ -+ serial_out(info, UART_MCR, info->MCR); -+ restore_flags(flags); -+ return 0; -+} -+ -+static int do_autoconfig(struct async_struct * info) -+{ -+ int irq, retval; -+ -+ if (!capable(CAP_SYS_ADMIN)) -+ return -EPERM; -+ -+ if (info->state->count > 1) -+ return -EBUSY; -+ -+ shutdown(info); -+ -+ autoconfig(info->state); -+ if ((info->state->flags & ASYNC_AUTO_IRQ) && -+ (info->state->port != 0 || info->state->iomem_base != 0) && -+ (info->state->type != PORT_UNKNOWN)) { -+ irq = detect_uart_irq(info->state); -+ if (irq > 0) -+ info->state->irq = irq; -+ } -+ -+ retval = startup(info); -+ if (retval) -+ return retval; -+ return 0; -+} -+ -+/* -+ * rs_break() --- routine which turns the break handling on or off -+ */ -+#if (LINUX_VERSION_CODE < 131394) /* Linux 2.1.66 */ -+static void send_break( struct async_struct * info, int duration) -+{ -+ if (!CONFIGURED_SERIAL_PORT(info)) -+ return; -+ current->state = TASK_INTERRUPTIBLE; -+ current->timeout = jiffies + duration; -+ cli(); -+ info->LCR |= UART_LCR_SBC; -+ serial_out(info, UART_LCR, info->LCR); -+ schedule(); -+ info->LCR &= ~UART_LCR_SBC; -+ serial_out(info, UART_LCR, info->LCR); -+ sti(); -+} -+#else -+static void rs_break(struct tty_struct *tty, int break_state) -+{ -+ struct async_struct * info = (struct async_struct *)tty->driver_data; -+ unsigned long flags; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_break")) -+ return; -+ -+ if (!CONFIGURED_SERIAL_PORT(info)) -+ return; -+ save_flags(flags); cli(); -+ if (break_state == -1) -+ info->LCR |= UART_LCR_SBC; -+ else -+ info->LCR &= ~UART_LCR_SBC; -+ serial_out(info, UART_LCR, info->LCR); -+ restore_flags(flags); -+} -+#endif -+ -+#ifdef CONFIG_SERIAL_MULTIPORT -+static int get_multiport_struct(struct async_struct * info, -+ struct serial_multiport_struct *retinfo) -+{ -+ struct serial_multiport_struct ret; -+ struct rs_multiport_struct *multi; -+ -+ multi = &rs_multiport[info->state->irq]; -+ -+ ret.port_monitor = multi->port_monitor; -+ -+ ret.port1 = multi->port1; -+ ret.mask1 = multi->mask1; -+ ret.match1 = multi->match1; -+ -+ ret.port2 = multi->port2; -+ ret.mask2 = multi->mask2; -+ ret.match2 = multi->match2; -+ -+ ret.port3 = multi->port3; -+ ret.mask3 = multi->mask3; -+ ret.match3 = multi->match3; -+ -+ ret.port4 = multi->port4; -+ ret.mask4 = multi->mask4; -+ ret.match4 = multi->match4; -+ -+ ret.irq = info->state->irq; -+ -+ if (copy_to_user(retinfo,&ret,sizeof(*retinfo))) -+ return -EFAULT; -+ return 0; -+} -+ -+static int set_multiport_struct(struct async_struct * info, -+ struct serial_multiport_struct *in_multi) -+{ -+ struct serial_multiport_struct new_multi; -+ struct rs_multiport_struct *multi; -+ struct serial_state *state; -+ int was_multi, now_multi; -+ int retval; -+ void (*handler)(int, void *, struct pt_regs *); -+ -+ if (!capable(CAP_SYS_ADMIN)) -+ return -EPERM; -+ state = info->state; -+ -+ if (copy_from_user(&new_multi, in_multi, -+ sizeof(struct serial_multiport_struct))) -+ return -EFAULT; -+ -+ if (new_multi.irq != state->irq || state->irq == 0 || -+ !IRQ_ports[state->irq]) -+ return -EINVAL; -+ -+ multi = &rs_multiport[state->irq]; -+ was_multi = (multi->port1 != 0); -+ -+ multi->port_monitor = new_multi.port_monitor; -+ -+ if (multi->port1) -+ release_region(multi->port1,1); -+ multi->port1 = new_multi.port1; -+ multi->mask1 = new_multi.mask1; -+ multi->match1 = new_multi.match1; -+ if (multi->port1) -+ request_region(multi->port1,1,"serial(multiport1)"); -+ -+ if (multi->port2) -+ release_region(multi->port2,1); -+ multi->port2 = new_multi.port2; -+ multi->mask2 = new_multi.mask2; -+ multi->match2 = new_multi.match2; -+ if (multi->port2) -+ request_region(multi->port2,1,"serial(multiport2)"); -+ -+ if (multi->port3) -+ release_region(multi->port3,1); -+ multi->port3 = new_multi.port3; -+ multi->mask3 = new_multi.mask3; -+ multi->match3 = new_multi.match3; -+ if (multi->port3) -+ request_region(multi->port3,1,"serial(multiport3)"); -+ -+ if (multi->port4) -+ release_region(multi->port4,1); -+ multi->port4 = new_multi.port4; -+ multi->mask4 = new_multi.mask4; -+ multi->match4 = new_multi.match4; -+ if (multi->port4) -+ request_region(multi->port4,1,"serial(multiport4)"); -+ -+ now_multi = (multi->port1 != 0); -+ -+ if (IRQ_ports[state->irq]->next_port && -+ (was_multi != now_multi)) { -+ free_irq(state->irq, &IRQ_ports[state->irq]); -+ if (now_multi) -+ handler = rs_interrupt_multi; -+ else -+ handler = rs_interrupt; -+ -+ retval = request_irq(state->irq, handler, SA_SHIRQ, -+ "serial", &IRQ_ports[state->irq]); -+ if (retval) { -+ printk("Couldn't reallocate serial interrupt " -+ "driver!!\n"); -+ } -+ } -+ return 0; -+} -+#endif -+ -+static int rs_ioctl(struct tty_struct *tty, struct file * file, -+ unsigned int cmd, unsigned long arg) -+{ -+ struct async_struct * info = (struct async_struct *)tty->driver_data; -+ struct async_icount cprev, cnow; /* kernel counter temps */ -+ struct serial_icounter_struct icount; -+ unsigned long flags; -+#if (LINUX_VERSION_CODE < 131394) /* Linux 2.1.66 */ -+ int retval, tmp; -+#endif -+ -+ if (serial_paranoia_check(info, tty->device, "rs_ioctl")) -+ return -ENODEV; -+ -+ if ((cmd != TIOCGSERIAL) && (cmd != TIOCSSERIAL) && -+ (cmd != TIOCSERCONFIG) && (cmd != TIOCSERGSTRUCT) && -+ (cmd != TIOCMIWAIT) && (cmd != TIOCGICOUNT)) { -+ if (tty->flags & (1 << TTY_IO_ERROR)) -+ return -EIO; -+ } -+ -+ switch (cmd) { -+#if (LINUX_VERSION_CODE < 131394) /* Linux 2.1.66 */ -+ case TCSBRK: /* SVID version: non-zero arg --> no break */ -+ retval = tty_check_change(tty); -+ if (retval) -+ return retval; -+ tty_wait_until_sent(tty, 0); -+ if (signal_pending(current)) -+ return -EINTR; -+ if (!arg) { -+ send_break(info, HZ/4); /* 1/4 second */ -+ if (signal_pending(current)) -+ return -EINTR; -+ } -+ return 0; -+ case TCSBRKP: /* support for POSIX tcsendbreak() */ -+ retval = tty_check_change(tty); -+ if (retval) -+ return retval; -+ tty_wait_until_sent(tty, 0); -+ if (signal_pending(current)) -+ return -EINTR; -+ send_break(info, arg ? arg*(HZ/10) : HZ/4); -+ if (signal_pending(current)) -+ return -EINTR; -+ return 0; -+ case TIOCGSOFTCAR: -+ tmp = C_CLOCAL(tty) ? 1 : 0; -+ if (copy_to_user((void *)arg, &tmp, sizeof(int))) -+ return -EFAULT; -+ return 0; -+ case TIOCSSOFTCAR: -+ if (copy_from_user(&tmp, (void *)arg, sizeof(int))) -+ return -EFAULT; -+ -+ tty->termios->c_cflag = -+ ((tty->termios->c_cflag & ~CLOCAL) | -+ (tmp ? CLOCAL : 0)); -+ return 0; -+#endif -+ case TIOCMGET: -+ return get_modem_info(info, (unsigned int *) arg); -+ case TIOCMBIS: -+ case TIOCMBIC: -+ case TIOCMSET: -+ return set_modem_info(info, cmd, (unsigned int *) arg); -+ case TIOCGSERIAL: -+ return get_serial_info(info, -+ (struct serial_struct *) arg); -+ case TIOCSSERIAL: -+ return set_serial_info(info, -+ (struct serial_struct *) arg); -+ case TIOCSERCONFIG: -+ return do_autoconfig(info); -+ -+ case TIOCSERGETLSR: /* Get line status register */ -+ return get_lsr_info(info, (unsigned int *) arg); -+ -+ case TIOCSERGSTRUCT: -+ if (copy_to_user((struct async_struct *) arg, -+ info, sizeof(struct async_struct))) -+ return -EFAULT; -+ return 0; -+ -+#ifdef CONFIG_SERIAL_MULTIPORT -+ case TIOCSERGETMULTI: -+ return get_multiport_struct(info, -+ (struct serial_multiport_struct *) arg); -+ case TIOCSERSETMULTI: -+ return set_multiport_struct(info, -+ (struct serial_multiport_struct *) arg); -+#endif -+ -+ /* -+ * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change -+ * - mask passed in arg for lines of interest -+ * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking) -+ * Caller should use TIOCGICOUNT to see which one it was -+ */ -+ case TIOCMIWAIT: -+ save_flags(flags); cli(); -+ /* note the counters on entry */ -+ cprev = info->state->icount; -+ restore_flags(flags); -+ /* Force modem status interrupts on */ -+ info->IER |= UART_IER_MSI; -+ serial_out(info, UART_IER, info->IER); -+ while (1) { -+ interruptible_sleep_on(&info->delta_msr_wait); -+ /* see if a signal did it */ -+ if (signal_pending(current)) -+ return -ERESTARTSYS; -+ save_flags(flags); cli(); -+ cnow = info->state->icount; /* atomic copy */ -+ restore_flags(flags); -+ if (cnow.rng == cprev.rng && cnow.dsr == cprev.dsr && -+ cnow.dcd == cprev.dcd && cnow.cts == cprev.cts) -+ return -EIO; /* no change => error */ -+ if ( ((arg & TIOCM_RNG) && (cnow.rng != cprev.rng)) || -+ ((arg & TIOCM_DSR) && (cnow.dsr != cprev.dsr)) || -+ ((arg & TIOCM_CD) && (cnow.dcd != cprev.dcd)) || -+ ((arg & TIOCM_CTS) && (cnow.cts != cprev.cts)) ) { -+ return 0; -+ } -+ cprev = cnow; -+ } -+ /* NOTREACHED */ -+ -+ /* -+ * Get counter of input serial line interrupts (DCD,RI,DSR,CTS) -+ * Return: write counters to the user passed counter struct -+ * NB: both 1->0 and 0->1 transitions are counted except for -+ * RI where only 0->1 is counted. -+ */ -+ case TIOCGICOUNT: -+ save_flags(flags); cli(); -+ cnow = info->state->icount; -+ restore_flags(flags); -+ icount.cts = cnow.cts; -+ icount.dsr = cnow.dsr; -+ icount.rng = cnow.rng; -+ icount.dcd = cnow.dcd; -+ icount.rx = cnow.rx; -+ icount.tx = cnow.tx; -+ icount.frame = cnow.frame; -+ icount.overrun = cnow.overrun; -+ icount.parity = cnow.parity; -+ icount.brk = cnow.brk; -+ icount.buf_overrun = cnow.buf_overrun; -+ -+ if (copy_to_user((void *)arg, &icount, sizeof(icount))) -+ return -EFAULT; -+ return 0; -+ case TIOCSERGWILD: -+ case TIOCSERSWILD: -+ /* "setserial -W" is called in Debian boot */ -+ printk ("TIOCSER?WILD ioctl obsolete, ignored.\n"); -+ return 0; -+ -+ default: -+ return -ENOIOCTLCMD; -+ } -+ return 0; -+} -+ -+static void rs_set_termios(struct tty_struct *tty, struct termios *old_termios) -+{ -+ struct async_struct *info = (struct async_struct *)tty->driver_data; -+ unsigned long flags; -+ unsigned int cflag = tty->termios->c_cflag; -+ -+ if ( (cflag == old_termios->c_cflag) -+ && ( RELEVANT_IFLAG(tty->termios->c_iflag) -+ == RELEVANT_IFLAG(old_termios->c_iflag))) -+ return; -+ -+ change_speed(info, old_termios); -+ -+ /* Handle transition to B0 status */ -+ if ((old_termios->c_cflag & CBAUD) && -+ !(cflag & CBAUD)) { -+ info->MCR &= ~(UART_MCR_DTR|UART_MCR_RTS); -+ save_flags(flags); cli(); -+ serial_out(info, UART_MCR, info->MCR); -+ restore_flags(flags); -+ } -+ -+ /* Handle transition away from B0 status */ -+ if (!(old_termios->c_cflag & CBAUD) && -+ (cflag & CBAUD)) { -+ info->MCR |= UART_MCR_DTR; -+ if (!(tty->termios->c_cflag & CRTSCTS) || -+ !test_bit(TTY_THROTTLED, &tty->flags)) { -+ info->MCR |= UART_MCR_RTS; -+ } -+ save_flags(flags); cli(); -+ serial_out(info, UART_MCR, info->MCR); -+ restore_flags(flags); -+ } -+ -+ /* Handle turning off CRTSCTS */ -+ if ((old_termios->c_cflag & CRTSCTS) && -+ !(tty->termios->c_cflag & CRTSCTS)) { -+ tty->hw_stopped = 0; -+ rs_start(tty); -+ } -+ -+#if 0 -+ /* -+ * No need to wake up processes in open wait, since they -+ * sample the CLOCAL flag once, and don't recheck it. -+ * XXX It's not clear whether the current behavior is correct -+ * or not. Hence, this may change..... -+ */ -+ if (!(old_termios->c_cflag & CLOCAL) && -+ (tty->termios->c_cflag & CLOCAL)) -+ wake_up_interruptible(&info->open_wait); -+#endif -+} -+ -+/* -+ * ------------------------------------------------------------ -+ * rs_close() -+ * -+ * This routine is called when the serial port gets closed. First, we -+ * wait for the last remaining data to be sent. Then, we unlink its -+ * async structure from the interrupt chain if necessary, and we free -+ * that IRQ if nothing is left in the chain. -+ * ------------------------------------------------------------ -+ */ -+static void rs_close(struct tty_struct *tty, struct file * filp) -+{ -+ struct async_struct * info = (struct async_struct *)tty->driver_data; -+ struct serial_state *state; -+ unsigned long flags; -+ -+ if (!info || serial_paranoia_check(info, tty->device, "rs_close")) -+ return; -+ -+ state = info->state; -+ -+ save_flags(flags); cli(); -+ -+ if (tty_hung_up_p(filp)) { -+ DBG_CNT("before DEC-hung"); -+ MOD_DEC_USE_COUNT; -+ restore_flags(flags); -+ return; -+ } -+ -+#ifdef SERIAL_DEBUG_OPEN -+ printk("rs_close ttys%d, count = %d\n", info->line, state->count); -+#endif -+ if ((tty->count == 1) && (state->count != 1)) { -+ /* -+ * Uh, oh. tty->count is 1, which means that the tty -+ * structure will be freed. state->count should always -+ * be one in these conditions. If it's greater than -+ * one, we've got real problems, since it means the -+ * serial port won't be shutdown. -+ */ -+ printk("rs_close: bad serial port count; tty->count is 1, " -+ "state->count is %d\n", state->count); -+ state->count = 1; -+ } -+ if (--state->count < 0) { -+ printk("rs_close: bad serial port count for ttys%d: %d\n", -+ info->line, state->count); -+ state->count = 0; -+ } -+ if (state->count) { -+ DBG_CNT("before DEC-2"); -+ MOD_DEC_USE_COUNT; -+ restore_flags(flags); -+ return; -+ } -+ info->flags |= ASYNC_CLOSING; -+ restore_flags(flags); -+ /* -+ * Save the termios structure, since this port may have -+ * separate termios for callout and dialin. -+ */ -+ if (info->flags & ASYNC_NORMAL_ACTIVE) -+ info->state->normal_termios = *tty->termios; -+ if (info->flags & ASYNC_CALLOUT_ACTIVE) -+ info->state->callout_termios = *tty->termios; -+ /* -+ * Now we wait for the transmit buffer to clear; and we notify -+ * the line discipline to only process XON/XOFF characters. -+ */ -+ tty->closing = 1; -+ if (state->closing_wait != ASYNC_CLOSING_WAIT_NONE) -+ tty_wait_until_sent(tty, state->closing_wait); -+ /* -+ * At this point we stop accepting input. To do this, we -+ * disable the receive line status interrupts, and tell the -+ * interrupt driver to stop checking the data ready bit in the -+ * line status register. -+ */ -+ info->IER &= ~UART_IER_RLSI; -+ info->read_status_mask &= ~UART_LSR_DR; -+ if (info->flags & ASYNC_INITIALIZED) { -+ serial_out(info, UART_IER, info->IER); -+ /* -+ * Before we drop DTR, make sure the UART transmitter -+ * has completely drained; this is especially -+ * important if there is a transmit FIFO! -+ */ -+ rs_wait_until_sent(tty, info->timeout); -+ } -+ shutdown(info); -+ if (tty->driver.flush_buffer) -+ tty->driver.flush_buffer(tty); -+ tty_ldisc_flush(tty); -+ tty->closing = 0; -+ info->event = 0; -+ info->tty = 0; -+ if (info->blocked_open) { -+ if (state->close_delay) { -+ set_current_state(TASK_INTERRUPTIBLE); -+ schedule_timeout(state->close_delay); -+ } -+ wake_up_interruptible(&info->open_wait); -+ } -+ info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE| -+ ASYNC_CLOSING); -+ wake_up_interruptible(&info->close_wait); -+ MOD_DEC_USE_COUNT; -+} -+ -+/* -+ * rs_wait_until_sent() --- wait until the transmitter is empty -+ */ -+static void rs_wait_until_sent(struct tty_struct *tty, int timeout) -+{ -+ struct async_struct * info = (struct async_struct *)tty->driver_data; -+ unsigned long orig_jiffies, char_time; -+ int lsr; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_wait_until_sent")) -+ return; -+ -+ if (info->state->type == PORT_UNKNOWN) -+ return; -+ -+ if (info->xmit_fifo_size == 0) -+ return; /* Just in case.... */ -+ -+ orig_jiffies = jiffies; -+ /* -+ * Set the check interval to be 1/5 of the estimated time to -+ * send a single character, and make it at least 1. The check -+ * interval should also be less than the timeout. -+ * -+ * Note: we have to use pretty tight timings here to satisfy -+ * the NIST-PCTS. -+ */ -+ char_time = (info->timeout - HZ/50) / info->xmit_fifo_size; -+ char_time = char_time / 5; -+ if (char_time == 0) -+ char_time = 1; -+ if (timeout && timeout < char_time) -+ char_time = timeout; -+ /* -+ * If the transmitter hasn't cleared in twice the approximate -+ * amount of time to send the entire FIFO, it probably won't -+ * ever clear. This assumes the UART isn't doing flow -+ * control, which is currently the case. Hence, if it ever -+ * takes longer than info->timeout, this is probably due to a -+ * UART bug of some kind. So, we clamp the timeout parameter at -+ * 2*info->timeout. -+ */ -+ if (!timeout || timeout > 2*info->timeout) -+ timeout = 2*info->timeout; -+#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT -+ printk("In rs_wait_until_sent(%d) check=%lu...", timeout, char_time); -+ printk("jiff=%lu...", jiffies); -+#endif -+ while (!((lsr = serial_inp(info, UART_LSR)) & UART_LSR_TEMT)) { -+#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT -+ printk("lsr = %d (jiff=%lu)...", lsr, jiffies); -+#endif -+ set_current_state(TASK_INTERRUPTIBLE); -+ schedule_timeout(char_time); -+ if (signal_pending(current)) -+ break; -+ if (timeout && time_after(jiffies, orig_jiffies + timeout)) -+ break; -+ } -+#ifdef SERIAL_DEBUG_RS_WAIT_UNTIL_SENT -+ printk("lsr = %d (jiff=%lu)...done\n", lsr, jiffies); -+#endif -+} -+ -+/* -+ * rs_hangup() --- called by tty_hangup() when a hangup is signaled. -+ */ -+static void rs_hangup(struct tty_struct *tty) -+{ -+ struct async_struct * info = (struct async_struct *)tty->driver_data; -+ struct serial_state *state = info->state; -+ -+ if (serial_paranoia_check(info, tty->device, "rs_hangup")) -+ return; -+ -+ state = info->state; -+ -+ rs_flush_buffer(tty); -+ if (info->flags & ASYNC_CLOSING) -+ return; -+ shutdown(info); -+ info->event = 0; -+ state->count = 0; -+ info->flags &= ~(ASYNC_NORMAL_ACTIVE|ASYNC_CALLOUT_ACTIVE); -+ info->tty = 0; -+ wake_up_interruptible(&info->open_wait); -+} -+ -+/* -+ * ------------------------------------------------------------ -+ * rs_open() and friends -+ * ------------------------------------------------------------ -+ */ -+static int block_til_ready(struct tty_struct *tty, struct file * filp, -+ struct async_struct *info) -+{ -+ DECLARE_WAITQUEUE(wait, current); -+ struct serial_state *state = info->state; -+ int retval; -+ int do_clocal = 0, extra_count = 0; -+ unsigned long flags; -+ -+ /* -+ * If the device is in the middle of being closed, then block -+ * until it's done, and then try again. -+ */ -+ if (tty_hung_up_p(filp) || -+ (info->flags & ASYNC_CLOSING)) { -+ if (info->flags & ASYNC_CLOSING) -+ interruptible_sleep_on(&info->close_wait); -+#ifdef SERIAL_DO_RESTART -+ return ((info->flags & ASYNC_HUP_NOTIFY) ? -+ -EAGAIN : -ERESTARTSYS); -+#else -+ return -EAGAIN; -+#endif -+ } -+ -+ /* -+ * If this is a callout device, then just make sure the normal -+ * device isn't being used. -+ */ -+ if (tty->driver.subtype == SERIAL_TYPE_CALLOUT) { -+ if (info->flags & ASYNC_NORMAL_ACTIVE) -+ return -EBUSY; -+ if ((info->flags & ASYNC_CALLOUT_ACTIVE) && -+ (info->flags & ASYNC_SESSION_LOCKOUT) && -+ (info->session != current->session)) -+ return -EBUSY; -+ if ((info->flags & ASYNC_CALLOUT_ACTIVE) && -+ (info->flags & ASYNC_PGRP_LOCKOUT) && -+ (info->pgrp != current->pgrp)) -+ return -EBUSY; -+ info->flags |= ASYNC_CALLOUT_ACTIVE; -+ return 0; -+ } -+ -+ /* -+ * If non-blocking mode is set, or the port is not enabled, -+ * then make the check up front and then exit. -+ */ -+ if ((filp->f_flags & O_NONBLOCK) || -+ (tty->flags & (1 << TTY_IO_ERROR))) { -+ if (info->flags & ASYNC_CALLOUT_ACTIVE) -+ return -EBUSY; -+ info->flags |= ASYNC_NORMAL_ACTIVE; -+ return 0; -+ } -+ -+ if (info->flags & ASYNC_CALLOUT_ACTIVE) { -+ if (state->normal_termios.c_cflag & CLOCAL) -+ do_clocal = 1; -+ } else { -+ if (tty->termios->c_cflag & CLOCAL) -+ do_clocal = 1; -+ } -+ -+ /* -+ * Block waiting for the carrier detect and the line to become -+ * free (i.e., not in use by the callout). While we are in -+ * this loop, state->count is dropped by one, so that -+ * rs_close() knows when to free things. We restore it upon -+ * exit, either normal or abnormal. -+ */ -+ retval = 0; -+ add_wait_queue(&info->open_wait, &wait); -+#ifdef SERIAL_DEBUG_OPEN -+ printk("block_til_ready before block: ttys%d, count = %d\n", -+ state->line, state->count); -+#endif -+ save_flags(flags); cli(); -+ if (!tty_hung_up_p(filp)) { -+ extra_count = 1; -+ state->count--; -+ } -+ restore_flags(flags); -+ info->blocked_open++; -+ while (1) { -+ save_flags(flags); cli(); -+ if (!(info->flags & ASYNC_CALLOUT_ACTIVE) && -+ (tty->termios->c_cflag & CBAUD)) -+ serial_out(info, UART_MCR, -+ serial_inp(info, UART_MCR) | -+ (UART_MCR_DTR | UART_MCR_RTS)); -+ restore_flags(flags); -+ set_current_state(TASK_INTERRUPTIBLE); -+ if (tty_hung_up_p(filp) || -+ !(info->flags & ASYNC_INITIALIZED)) { -+#ifdef SERIAL_DO_RESTART -+ if (info->flags & ASYNC_HUP_NOTIFY) -+ retval = -EAGAIN; -+ else -+ retval = -ERESTARTSYS; -+#else -+ retval = -EAGAIN; -+#endif -+ break; -+ } -+ if (!(info->flags & ASYNC_CALLOUT_ACTIVE) && -+ !(info->flags & ASYNC_CLOSING) && -+ (do_clocal || (serial_in(info, UART_MSR) & -+ UART_MSR_DCD))) -+ break; -+ if (signal_pending(current)) { -+ retval = -ERESTARTSYS; -+ break; -+ } -+#ifdef SERIAL_DEBUG_OPEN -+ printk("block_til_ready blocking: ttys%d, count = %d\n", -+ info->line, state->count); -+#endif -+ schedule(); -+ } -+ set_current_state(TASK_RUNNING); -+ remove_wait_queue(&info->open_wait, &wait); -+ if (extra_count) -+ state->count++; -+ info->blocked_open--; -+#ifdef SERIAL_DEBUG_OPEN -+ printk("block_til_ready after blocking: ttys%d, count = %d\n", -+ info->line, state->count); -+#endif -+ if (retval) -+ return retval; -+ info->flags |= ASYNC_NORMAL_ACTIVE; -+ return 0; -+} -+ -+static int get_async_struct(int line, struct async_struct **ret_info) -+{ -+ struct async_struct *info; -+ struct serial_state *sstate; -+ -+ sstate = rs_table + line; -+ sstate->count++; -+ if (sstate->info) { -+ *ret_info = sstate->info; -+ return 0; -+ } -+ info = kmalloc(sizeof(struct async_struct), GFP_KERNEL); -+ if (!info) { -+ sstate->count--; -+ return -ENOMEM; -+ } -+ memset(info, 0, sizeof(struct async_struct)); -+ init_waitqueue_head(&info->open_wait); -+ init_waitqueue_head(&info->close_wait); -+ init_waitqueue_head(&info->delta_msr_wait); -+ info->magic = SERIAL_MAGIC; -+ info->port = sstate->port; -+ info->flags = sstate->flags; -+ info->io_type = sstate->io_type; -+ info->iomem_base = sstate->iomem_base; -+ info->iomem_reg_shift = sstate->iomem_reg_shift; -+ info->xmit_fifo_size = sstate->xmit_fifo_size; -+ info->line = line; -+ info->tqueue.routine = do_softint; -+ info->tqueue.data = info; -+ info->state = sstate; -+ if (sstate->info) { -+ kfree(info); -+ *ret_info = sstate->info; -+ return 0; -+ } -+ *ret_info = sstate->info = info; -+ return 0; -+} -+ -+/* -+ * This routine is called whenever a serial port is opened. It -+ * enables interrupts for a serial port, linking in its async structure into -+ * the IRQ chain. It also performs the serial-specific -+ * initialization for the tty structure. -+ * -+ * Note that on failure, we don't decrement the module use count - the tty -+ * later will call rs_close, which will decrement it for us as long as -+ * tty->driver_data is set non-NULL. --rmk -+ */ -+static int rs_open(struct tty_struct *tty, struct file * filp) -+{ -+ struct async_struct *info; -+ int retval, line; -+ unsigned long page; -+ -+ MOD_INC_USE_COUNT; -+ line = MINOR(tty->device) - tty->driver.minor_start; -+ if ((line < 0) || (line >= NR_PORTS)) { -+ MOD_DEC_USE_COUNT; -+ return -ENODEV; -+ } -+ retval = get_async_struct(line, &info); -+ if (retval) { -+ MOD_DEC_USE_COUNT; -+ return retval; -+ } -+ tty->driver_data = info; -+ info->tty = tty; -+ if (serial_paranoia_check(info, tty->device, "rs_open")) -+ return -ENODEV; -+ -+#ifdef SERIAL_DEBUG_OPEN -+ printk("rs_open %s%d, count = %d\n", tty->driver.name, info->line, -+ info->state->count); -+#endif -+#if (LINUX_VERSION_CODE > 0x20100) -+ info->tty->low_latency = (info->flags & ASYNC_LOW_LATENCY) ? 1 : 0; -+#endif -+ -+ /* -+ * This relies on lock_kernel() stuff so wants tidying for 2.5 -+ */ -+ if (!tmp_buf) { -+ page = get_zeroed_page(GFP_KERNEL); -+ if (!page) -+ return -ENOMEM; -+ if (tmp_buf) -+ free_page(page); -+ else -+ tmp_buf = (unsigned char *) page; -+ } -+ -+ /* -+ * If the port is the middle of closing, bail out now -+ */ -+ if (tty_hung_up_p(filp) || -+ (info->flags & ASYNC_CLOSING)) { -+ if (info->flags & ASYNC_CLOSING) -+ interruptible_sleep_on(&info->close_wait); -+#ifdef SERIAL_DO_RESTART -+ return ((info->flags & ASYNC_HUP_NOTIFY) ? -+ -EAGAIN : -ERESTARTSYS); -+#else -+ return -EAGAIN; -+#endif -+ } -+ -+ /* -+ * Start up serial port -+ */ -+ retval = startup(info); -+ if (retval) -+ return retval; -+ -+ retval = block_til_ready(tty, filp, info); -+ if (retval) { -+#ifdef SERIAL_DEBUG_OPEN -+ printk("rs_open returning after block_til_ready with %d\n", -+ retval); -+#endif -+ return retval; -+ } -+ -+ if ((info->state->count == 1) && -+ (info->flags & ASYNC_SPLIT_TERMIOS)) { -+ if (tty->driver.subtype == SERIAL_TYPE_NORMAL) -+ *tty->termios = info->state->normal_termios; -+ else -+ *tty->termios = info->state->callout_termios; -+ change_speed(info, 0); -+ } -+#ifdef CONFIG_SERIAL_CONSOLE -+ if (sercons.cflag && sercons.index == line) { -+ tty->termios->c_cflag = sercons.cflag; -+ sercons.cflag = 0; -+ change_speed(info, 0); -+ } -+#endif -+ info->session = current->session; -+ info->pgrp = current->pgrp; -+ -+#ifdef SERIAL_DEBUG_OPEN -+ printk("rs_open ttys%d successful...", info->line); -+#endif -+ return 0; -+} -+ -+/* -+ * /proc fs routines.... -+ */ -+ -+static inline int line_info(char *buf, struct serial_state *state) -+{ -+ struct async_struct *info = state->info, scr_info; -+ char stat_buf[30], control, status; -+ int ret; -+ unsigned long flags; -+ -+ /* -+ * Return zero characters for ports not claimed by driver. -+ */ -+ if (state->type == PORT_UNKNOWN) { -+ return 0; /* ignore unused ports */ -+ } -+ -+ ret = sprintf(buf, "%d: uart:%s port:%lX irq:%d", -+ state->line, uart_config[state->type].name, -+ (state->port ? state->port : (long)state->iomem_base), -+ state->irq); -+ -+ /* -+ * Figure out the current RS-232 lines -+ */ -+ if (!info) { -+ info = &scr_info; /* This is just for serial_{in,out} */ -+ -+ info->magic = SERIAL_MAGIC; -+ info->port = state->port; -+ info->flags = state->flags; -+ info->hub6 = state->hub6; -+ info->io_type = state->io_type; -+ info->iomem_base = state->iomem_base; -+ info->iomem_reg_shift = state->iomem_reg_shift; -+ info->quot = 0; -+ info->tty = 0; -+ } -+ save_flags(flags); cli(); -+ status = serial_in(info, UART_MSR); -+ control = info != &scr_info ? info->MCR : serial_in(info, UART_MCR); -+ restore_flags(flags); -+ -+ stat_buf[0] = 0; -+ stat_buf[1] = 0; -+ if (control & UART_MCR_RTS) -+ strcat(stat_buf, "|RTS"); -+ if (status & UART_MSR_CTS) -+ strcat(stat_buf, "|CTS"); -+ if (control & UART_MCR_DTR) -+ strcat(stat_buf, "|DTR"); -+ if (status & UART_MSR_DSR) -+ strcat(stat_buf, "|DSR"); -+ if (status & UART_MSR_DCD) -+ strcat(stat_buf, "|CD"); -+ if (status & UART_MSR_RI) -+ strcat(stat_buf, "|RI"); -+ -+ if (info->quot) { -+ ret += sprintf(buf+ret, " baud:%d", -+ state->baud_base / info->quot); -+ } -+ -+ ret += sprintf(buf+ret, " tx:%d rx:%d", -+ state->icount.tx, state->icount.rx); -+ -+ if (state->icount.frame) -+ ret += sprintf(buf+ret, " fe:%d", state->icount.frame); -+ -+ if (state->icount.parity) -+ ret += sprintf(buf+ret, " pe:%d", state->icount.parity); -+ -+ if (state->icount.brk) -+ ret += sprintf(buf+ret, " brk:%d", state->icount.brk); -+ -+ if (state->icount.overrun) -+ ret += sprintf(buf+ret, " oe:%d", state->icount.overrun); -+ -+ /* -+ * Last thing is the RS-232 status lines -+ */ -+ ret += sprintf(buf+ret, " %s\n", stat_buf+1); -+ return ret; -+} -+ -+static int rs_read_proc(char *page, char **start, off_t off, int count, -+ int *eof, void *data) -+{ -+ int i, len = 0, l; -+ off_t begin = 0; -+ -+ len += sprintf(page, "serinfo:1.0 driver:%s%s revision:%s\n", -+ serial_version, LOCAL_VERSTRING, serial_revdate); -+ for (i = 0; i < NR_PORTS && len < 4000; i++) { -+ l = line_info(page + len, &rs_table[i]); -+ len += l; -+ if (len+begin > off+count) -+ goto done; -+ if (len+begin < off) { -+ begin += len; -+ len = 0; -+ } -+ } -+ *eof = 1; -+done: -+ if (off >= len+begin) -+ return 0; -+ *start = page + (off-begin); -+ return ((count < begin+len-off) ? count : begin+len-off); -+} -+ -+/* -+ * --------------------------------------------------------------------- -+ * rs_init() and friends -+ * -+ * rs_init() is called at boot-time to initialize the serial driver. -+ * --------------------------------------------------------------------- -+ */ -+ -+/* -+ * This routine prints out the appropriate serial driver version -+ * number, and identifies which options were configured into this -+ * driver. -+ */ -+static char serial_options[] __initdata = -+#ifdef CONFIG_HUB6 -+ " HUB-6" -+#define SERIAL_OPT -+#endif -+#ifdef CONFIG_SERIAL_MANY_PORTS -+ " MANY_PORTS" -+#define SERIAL_OPT -+#endif -+#ifdef CONFIG_SERIAL_MULTIPORT -+ " MULTIPORT" -+#define SERIAL_OPT -+#endif -+#ifdef CONFIG_SERIAL_SHARE_IRQ -+ " SHARE_IRQ" -+#define SERIAL_OPT -+#endif -+#ifdef CONFIG_SERIAL_DETECT_IRQ -+ " DETECT_IRQ" -+#define SERIAL_OPT -+#endif -+#ifdef ENABLE_SERIAL_PCI -+ " SERIAL_PCI" -+#define SERIAL_OPT -+#endif -+#ifdef ENABLE_SERIAL_PNP -+ " ISAPNP" -+#define SERIAL_OPT -+#endif -+#ifdef ENABLE_SERIAL_ACPI -+ " SERIAL_ACPI" -+#define SERIAL_OPT -+#endif -+#ifdef SERIAL_OPT -+ " enabled\n"; -+#else -+ " no serial options enabled\n"; -+#endif -+#undef SERIAL_OPT -+ -+static _INLINE_ void show_serial_version(void) -+{ -+ printk(KERN_INFO "%s version %s%s (%s) with%s", serial_name, -+ serial_version, LOCAL_VERSTRING, serial_revdate, -+ serial_options); -+} -+ -+/* -+ * This routine detect the IRQ of a serial port by clearing OUT2 when -+ * no UART interrupt are requested (IER = 0) (*GPL*). This seems to work at -+ * each time, as long as no other device permanently request the IRQ. -+ * If no IRQ is detected, or multiple IRQ appear, this function returns 0. -+ * The variable "state" and the field "state->port" should not be null. -+ */ -+static unsigned detect_uart_irq (struct serial_state * state) -+{ -+ int irq; -+ unsigned long irqs; -+ unsigned char save_mcr, save_ier; -+ struct async_struct scr_info; /* serial_{in,out} because HUB6 */ -+ -+#ifdef CONFIG_SERIAL_MANY_PORTS -+ unsigned char save_ICP=0; /* no warning */ -+ unsigned short ICP=0; -+ -+ if (state->flags & ASYNC_FOURPORT) { -+ ICP = (state->port & 0xFE0) | 0x01F; -+ save_ICP = inb_p(ICP); -+ outb_p(0x80, ICP); -+ (void) inb_p(ICP); -+ } -+#endif -+ scr_info.magic = SERIAL_MAGIC; -+ scr_info.state = state; -+ scr_info.port = state->port; -+ scr_info.flags = state->flags; -+#ifdef CONFIG_HUB6 -+ scr_info.hub6 = state->hub6; -+#endif -+ scr_info.io_type = state->io_type; -+ scr_info.iomem_base = state->iomem_base; -+ scr_info.iomem_reg_shift = state->iomem_reg_shift; -+ -+ /* forget possible initially masked and pending IRQ */ -+ probe_irq_off(probe_irq_on()); -+ save_mcr = serial_inp(&scr_info, UART_MCR); -+ save_ier = serial_inp(&scr_info, UART_IER); -+ serial_outp(&scr_info, UART_MCR, UART_MCR_OUT1 | UART_MCR_OUT2); -+ -+ irqs = probe_irq_on(); -+ serial_outp(&scr_info, UART_MCR, 0); -+ udelay (10); -+ if (state->flags & ASYNC_FOURPORT) { -+ serial_outp(&scr_info, UART_MCR, -+ UART_MCR_DTR | UART_MCR_RTS); -+ } else { -+ serial_outp(&scr_info, UART_MCR, -+ UART_MCR_DTR | UART_MCR_RTS | UART_MCR_OUT2); -+ } -+ serial_outp(&scr_info, UART_IER, 0x0f); /* enable all intrs */ -+ (void)serial_inp(&scr_info, UART_LSR); -+ (void)serial_inp(&scr_info, UART_RX); -+ (void)serial_inp(&scr_info, UART_IIR); -+ (void)serial_inp(&scr_info, UART_MSR); -+ serial_outp(&scr_info, UART_TX, 0xFF); -+ udelay (20); -+ irq = probe_irq_off(irqs); -+ -+ serial_outp(&scr_info, UART_MCR, save_mcr); -+ serial_outp(&scr_info, UART_IER, save_ier); -+#ifdef CONFIG_SERIAL_MANY_PORTS -+ if (state->flags & ASYNC_FOURPORT) -+ outb_p(save_ICP, ICP); -+#endif -+ return (irq > 0)? irq : 0; -+} -+ -+/* -+ * 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 async_struct *info) -+{ -+ unsigned char old_fcr, old_mcr, old_dll, old_dlm; -+ int count; -+ -+ old_fcr = serial_inp(info, UART_FCR); -+ old_mcr = serial_inp(info, UART_MCR); -+ serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO | -+ UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT); -+ serial_outp(info, UART_MCR, UART_MCR_LOOP); -+ serial_outp(info, UART_LCR, UART_LCR_DLAB); -+ old_dll = serial_inp(info, UART_DLL); -+ old_dlm = serial_inp(info, UART_DLM); -+ serial_outp(info, UART_DLL, 0x01); -+ serial_outp(info, UART_DLM, 0x00); -+ serial_outp(info, UART_LCR, 0x03); -+ for (count = 0; count < 256; count++) -+ serial_outp(info, UART_TX, count); -+ mdelay(20); -+ for (count = 0; (serial_inp(info, UART_LSR) & UART_LSR_DR) && -+ (count < 256); count++) -+ serial_inp(info, UART_RX); -+ serial_outp(info, UART_FCR, old_fcr); -+ serial_outp(info, UART_MCR, old_mcr); -+ serial_outp(info, UART_LCR, UART_LCR_DLAB); -+ serial_outp(info, UART_DLL, old_dll); -+ serial_outp(info, UART_DLM, old_dlm); -+ -+ return count; -+} -+ -+/* -+ * 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_startech_uarts(struct async_struct *info, -+ struct serial_state *state, -+ unsigned long flags) -+{ -+ unsigned char scratch, scratch2, scratch3, scratch4; -+ -+ /* -+ * 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) -+ */ -+ if (state->type == PORT_16550A) { -+ /* -+ * 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). -+ */ -+ info->ACR = 0; -+ serial_out(info, UART_LCR, 0xBF); -+ serial_out(info, UART_EFR, 0x10); -+ serial_out(info, UART_LCR, 0x00); -+ /* Check for Oxford Semiconductor 16C950 */ -+ scratch = serial_icr_read(info, UART_ID1); -+ scratch2 = serial_icr_read(info, UART_ID2); -+ scratch3 = serial_icr_read(info, UART_ID3); -+ -+ if (scratch == 0x16 && scratch2 == 0xC9 && -+ (scratch3 == 0x50 || scratch3 == 0x52 || -+ scratch3 == 0x54)) { -+ state->type = PORT_16C950; -+ state->revision = serial_icr_read(info, UART_REV) | -+ (scratch3 << 8); -+ return; -+ } -+ } -+ -+ /* -+ * We check for a XR16C850 by setting DLL and DLM to 0, and -+ * then reading back DLL and DLM. If DLM reads back 0x10, -+ * then the UART is a XR16C850 and the DLL contains the chip -+ * revision. If DLM reads back 0x14, then the UART is a -+ * XR16C854. -+ * -+ */ -+ -+ /* Save the DLL and DLM */ -+ -+ serial_outp(info, UART_LCR, UART_LCR_DLAB); -+ scratch3 = serial_inp(info, UART_DLL); -+ scratch4 = serial_inp(info, UART_DLM); -+ -+ serial_outp(info, UART_DLL, 0); -+ serial_outp(info, UART_DLM, 0); -+ scratch2 = serial_inp(info, UART_DLL); -+ scratch = serial_inp(info, UART_DLM); -+ serial_outp(info, UART_LCR, 0); -+ -+ if (scratch == 0x10 || scratch == 0x14) { -+ if (scratch == 0x10) -+ state->revision = scratch2; -+ state->type = PORT_16850; -+ return; -+ } -+ -+ /* Restore the DLL and DLM */ -+ -+ serial_outp(info, UART_LCR, UART_LCR_DLAB); -+ serial_outp(info, UART_DLL, scratch3); -+ serial_outp(info, UART_DLM, scratch4); -+ serial_outp(info, UART_LCR, 0); -+ /* -+ * 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(info) == 64) -+ state->type = PORT_16654; -+ else -+ state->type = PORT_16650V2; -+} -+ -+/* -+ * 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 serial_state * state) -+{ -+ unsigned char status1, status2, scratch, scratch2, scratch3; -+ unsigned char save_lcr, save_mcr; -+ struct async_struct *info, scr_info; -+ unsigned long flags; -+ -+ state->type = PORT_UNKNOWN; -+ -+#ifdef SERIAL_DEBUG_AUTOCONF -+ printk("Testing ttyS%d (0x%04lx, 0x%04x)...\n", state->line, -+ state->port, (unsigned) state->iomem_base); -+#endif -+ -+ if (!CONFIGURED_SERIAL_PORT(state)) -+ return; -+ -+ info = &scr_info; /* This is just for serial_{in,out} */ -+ -+ info->magic = SERIAL_MAGIC; -+ info->state = state; -+ info->port = state->port; -+ info->flags = state->flags; -+#ifdef CONFIG_HUB6 -+ info->hub6 = state->hub6; -+#endif -+ info->io_type = state->io_type; -+ info->iomem_base = state->iomem_base; -+ info->iomem_reg_shift = state->iomem_reg_shift; -+ -+ save_flags(flags); cli(); -+ -+ if (!(state->flags & ASYNC_BUGGY_UART) && -+ !state->iomem_base) { -+ /* -+ * 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. -+ */ -+ scratch = serial_inp(info, UART_IER); -+ serial_outp(info, UART_IER, 0); -+#ifdef __i386__ -+ outb(0xff, 0x080); -+#endif -+ scratch2 = serial_inp(info, UART_IER); -+ serial_outp(info, UART_IER, 0x0F); -+#ifdef __i386__ -+ outb(0, 0x080); -+#endif -+ scratch3 = serial_inp(info, UART_IER); -+ serial_outp(info, UART_IER, scratch); -+ if (scratch2 || scratch3 != 0x0F) { -+#ifdef SERIAL_DEBUG_AUTOCONF -+ printk("serial: ttyS%d: simple autoconfig failed " -+ "(%02x, %02x)\n", state->line, -+ scratch2, scratch3); -+#endif -+ restore_flags(flags); -+ return; /* We failed; there's nothing here */ -+ } -+ } -+ -+ save_mcr = serial_in(info, UART_MCR); -+ save_lcr = serial_in(info, 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 (!(state->flags & ASYNC_SKIP_TEST)) { -+ serial_outp(info, UART_MCR, UART_MCR_LOOP | 0x0A); -+ status1 = serial_inp(info, UART_MSR) & 0xF0; -+ serial_outp(info, UART_MCR, save_mcr); -+ if (status1 != 0x90) { -+#ifdef SERIAL_DEBUG_AUTOCONF -+ printk("serial: ttyS%d: no UART loopback failed\n", -+ state->line); -+#endif -+ restore_flags(flags); -+ return; -+ } -+ } -+ serial_outp(info, UART_LCR, 0xBF); /* set up for StarTech test */ -+ serial_outp(info, UART_EFR, 0); /* EFR is the same as FCR */ -+ serial_outp(info, UART_LCR, 0); -+ serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO); -+ scratch = serial_in(info, UART_IIR) >> 6; -+ switch (scratch) { -+ case 0: -+ state->type = PORT_16450; -+ break; -+ case 1: -+ state->type = PORT_UNKNOWN; -+ break; -+ case 2: -+ state->type = PORT_16550; -+ break; -+ case 3: -+ state->type = PORT_16550A; -+ break; -+ } -+ if (state->type == PORT_16550A) { -+ /* Check for Startech UART's */ -+ serial_outp(info, UART_LCR, UART_LCR_DLAB); -+ if (serial_in(info, UART_EFR) == 0) { -+ serial_outp(info, UART_EFR, 0xA8); -+ if (serial_in(info, UART_EFR) == 0) { -+ /* We are a NS16552D/Motorola -+ * 8xxx DUART, stop. */ -+ goto out; -+ } -+ state->type = PORT_16650; -+ serial_outp(info, UART_EFR, 0); -+ } else { -+ serial_outp(info, UART_LCR, 0xBF); -+ if (serial_in(info, UART_EFR) == 0) -+ autoconfig_startech_uarts(info, state, flags); -+ } -+ } -+ if (state->type == PORT_16550A) { -+ /* Check for TI 16750 */ -+ serial_outp(info, UART_LCR, save_lcr | UART_LCR_DLAB); -+ serial_outp(info, UART_FCR, -+ UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE); -+ scratch = serial_in(info, UART_IIR) >> 5; -+ if (scratch == 7) { -+ /* -+ * If this is a 16750, and not a cheap UART -+ * clone, then it should only go into 64 byte -+ * mode if the UART_FCR7_64BYTE bit was set -+ * while UART_LCR_DLAB was latched. -+ */ -+ serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO); -+ serial_outp(info, UART_LCR, 0); -+ serial_outp(info, UART_FCR, -+ UART_FCR_ENABLE_FIFO | UART_FCR7_64BYTE); -+ scratch = serial_in(info, UART_IIR) >> 5; -+ if (scratch == 6) -+ state->type = PORT_16750; -+ } -+ serial_outp(info, UART_FCR, UART_FCR_ENABLE_FIFO); -+ } -+#if defined(CONFIG_SERIAL_RSA) && defined(MODULE) -+ if (state->type == PORT_16550A) { -+ int i; -+ -+ for (i = 0 ; i < PORT_RSA_MAX ; ++i) { -+ if (!probe_rsa[i] && !force_rsa[i]) -+ break; -+ if (((probe_rsa[i] != state->port) || -+ check_region(state->port + UART_RSA_BASE, 16)) && -+ (force_rsa[i] != state->port)) -+ continue; -+ if (!enable_rsa(info)) -+ continue; -+ state->type = PORT_RSA; -+ state->baud_base = SERIAL_RSA_BAUD_BASE; -+ break; -+ } -+ } -+#endif -+out: -+ serial_outp(info, UART_LCR, save_lcr); -+ if (state->type == PORT_16450) { -+ scratch = serial_in(info, UART_SCR); -+ serial_outp(info, UART_SCR, 0xa5); -+ status1 = serial_in(info, UART_SCR); -+ serial_outp(info, UART_SCR, 0x5a); -+ status2 = serial_in(info, UART_SCR); -+ serial_outp(info, UART_SCR, scratch); -+ -+ if ((status1 != 0xa5) || (status2 != 0x5a)) -+ state->type = PORT_8250; -+ } -+ state->xmit_fifo_size = uart_config[state->type].dfl_xmit_fifo_size; -+ -+ if (state->type == PORT_UNKNOWN) { -+ restore_flags(flags); -+ return; -+ } -+ -+ if (info->port) { -+#ifdef CONFIG_SERIAL_RSA -+ if (state->type == PORT_RSA) -+ request_region(info->port + UART_RSA_BASE, 16, -+ "serial_rsa(auto)"); -+ else -+#endif -+ request_region(info->port,8,"serial(auto)"); -+ } -+ -+ /* -+ * Reset the UART. -+ */ -+#ifdef CONFIG_SERIAL_RSA -+ if (state->type == PORT_RSA) -+ serial_outp(info, UART_RSA_FRR, 0); -+#endif -+ serial_outp(info, UART_MCR, save_mcr); -+ serial_outp(info, UART_FCR, (UART_FCR_ENABLE_FIFO | -+ UART_FCR_CLEAR_RCVR | -+ UART_FCR_CLEAR_XMIT)); -+ serial_outp(info, UART_FCR, 0); -+ (void)serial_in(info, UART_RX); -+ serial_outp(info, UART_IER, 0); -+ -+ restore_flags(flags); -+} -+ -+int register_serial(struct serial_struct *req); -+void unregister_serial(int line); -+ -+#if (LINUX_VERSION_CODE > 0x20100) -+EXPORT_SYMBOL(register_serial); -+EXPORT_SYMBOL(unregister_serial); -+#else -+static struct symbol_table serial_syms = { -+#include <linux/symtab_begin.h> -+ X(register_serial), -+ X(unregister_serial), -+#include <linux/symtab_end.h> -+}; -+#endif -+ -+ -+#if defined(ENABLE_SERIAL_PCI) || defined(ENABLE_SERIAL_PNP) -+ -+static void __devinit printk_pnp_dev_id(unsigned short vendor, -+ unsigned short device) -+{ -+ printk("%c%c%c%x%x%x%x", -+ 'A' + ((vendor >> 2) & 0x3f) - 1, -+ 'A' + (((vendor & 3) << 3) | ((vendor >> 13) & 7)) - 1, -+ 'A' + ((vendor >> 8) & 0x1f) - 1, -+ (device >> 4) & 0x0f, -+ device & 0x0f, -+ (device >> 12) & 0x0f, -+ (device >> 8) & 0x0f); -+} -+ -+static _INLINE_ int get_pci_port(struct pci_dev *dev, -+ struct pci_board *board, -+ struct serial_struct *req, -+ int idx) -+{ -+ unsigned long port; -+ int base_idx; -+ int max_port; -+ int offset; -+ -+ base_idx = SPCI_FL_GET_BASE(board->flags); -+ if (board->flags & SPCI_FL_BASE_TABLE) -+ base_idx += idx; -+ -+ if (board->flags & SPCI_FL_REGION_SZ_CAP) { -+ max_port = pci_resource_len(dev, base_idx) / 8; -+ if (idx >= max_port) -+ return 1; -+ } -+ -+ offset = board->first_uart_offset; -+ -+ /* Timedia/SUNIX uses a mixture of BARs and offsets */ -+ /* Ugh, this is ugly as all hell --- TYT */ -+ if(dev->vendor == PCI_VENDOR_ID_TIMEDIA ) /* 0x1409 */ -+ switch(idx) { -+ case 0: base_idx=0; -+ break; -+ case 1: base_idx=0; offset=8; -+ break; -+ case 2: base_idx=1; -+ break; -+ case 3: base_idx=1; offset=8; -+ break; -+ case 4: /* BAR 2*/ -+ case 5: /* BAR 3 */ -+ case 6: /* BAR 4*/ -+ case 7: base_idx=idx-2; /* BAR 5*/ -+ } -+ -+ /* Some Titan cards are also a little weird */ -+ if (dev->vendor == PCI_VENDOR_ID_TITAN && -+ (dev->device == PCI_DEVICE_ID_TITAN_400L || -+ dev->device == PCI_DEVICE_ID_TITAN_800L)) { -+ switch (idx) { -+ case 0: base_idx = 1; -+ break; -+ case 1: base_idx = 2; -+ break; -+ default: -+ base_idx = 4; -+ offset = 8 * (idx - 2); -+ } -+ -+ } -+ -+ /* HP's Diva chip puts the 4th/5th serial port further out, and -+ * some serial ports are supposed to be hidden on certain models. -+ */ -+ if (dev->vendor == PCI_VENDOR_ID_HP && -+ dev->device == PCI_DEVICE_ID_HP_SAS) { -+ switch (dev->subsystem_device) { -+ case 0x104B: /* Maestro */ -+ if (idx == 3) idx++; -+ break; -+ case 0x1282: /* Everest / Longs Peak */ -+ if (idx > 0) idx++; -+ if (idx > 2) idx++; -+ break; -+ } -+ if (idx > 2) { -+ offset = 0x18; -+ } -+ } -+ -+ port = pci_resource_start(dev, base_idx) + offset; -+ -+ if ((board->flags & SPCI_FL_BASE_TABLE) == 0) -+ port += idx * (board->uart_offset ? board->uart_offset : 8); -+ -+ if (IS_PCI_REGION_IOPORT(dev, base_idx)) { -+ req->port = port; -+ if (HIGH_BITS_OFFSET) -+ req->port_high = port >> HIGH_BITS_OFFSET; -+ else -+ req->port_high = 0; -+ return 0; -+ } -+ req->io_type = SERIAL_IO_MEM; -+ req->iomem_base = ioremap(port, board->uart_offset); -+ req->iomem_reg_shift = board->reg_shift; -+ req->port = 0; -+ return 0; -+} -+ -+static _INLINE_ int get_pci_irq(struct pci_dev *dev, -+ struct pci_board *board, -+ int idx) -+{ -+ int base_idx; -+ -+ if ((board->flags & SPCI_FL_IRQRESOURCE) == 0) -+ return dev->irq; -+ -+ base_idx = SPCI_FL_GET_IRQBASE(board->flags); -+ if (board->flags & SPCI_FL_IRQ_TABLE) -+ base_idx += idx; -+ -+ return PCI_IRQ_RESOURCE(dev, base_idx); -+} -+ -+/* -+ * Common enabler code shared by both PCI and ISAPNP probes -+ */ -+static void __devinit start_pci_pnp_board(struct pci_dev *dev, -+ struct pci_board *board) -+{ -+ int k, line; -+ struct serial_struct serial_req; -+ int base_baud; -+ -+ if (PREPARE_FUNC(dev) && (PREPARE_FUNC(dev))(dev) < 0) { -+ printk("serial: PNP device '"); -+ printk_pnp_dev_id(dev->vendor, dev->device); -+ printk("' prepare failed\n"); -+ return; -+ } -+ -+ if (ACTIVATE_FUNC(dev) && (ACTIVATE_FUNC(dev))(dev) < 0) { -+ printk("serial: PNP device '"); -+ printk_pnp_dev_id(dev->vendor, dev->device); -+ printk("' activate failed\n"); -+ return; -+ } -+ -+ /* -+ * Run the initialization function, if any -+ */ -+ if (board->init_fn && ((board->init_fn)(dev, board, 1) != 0)) -+ return; -+ -+ /* -+ * Register the serial board in the array if we need to -+ * shutdown the board on a module unload or card removal -+ */ -+ if (DEACTIVATE_FUNC(dev) || board->init_fn) { -+ for (k=0; k < NR_PCI_BOARDS; k++) -+ if (serial_pci_board[k].dev == 0) -+ break; -+ if (k >= NR_PCI_BOARDS) -+ return; -+ serial_pci_board[k].board = *board; -+ serial_pci_board[k].dev = dev; -+ } -+ -+ base_baud = board->base_baud; -+ if (!base_baud) -+ base_baud = BASE_BAUD; -+ memset(&serial_req, 0, sizeof(serial_req)); -+ -+ for (k=0; k < board->num_ports; k++) { -+ serial_req.irq = get_pci_irq(dev, board, k); -+ if (get_pci_port(dev, board, &serial_req, k)) -+ break; -+ serial_req.flags = ASYNC_SKIP_TEST | ASYNC_AUTOPROBE; -+#ifdef SERIAL_DEBUG_PCI -+ printk("Setup PCI/PNP port: port %x, irq %d, type %d\n", -+ serial_req.port, serial_req.irq, serial_req.io_type); -+#endif -+ line = register_serial(&serial_req); -+ if (line < 0) -+ break; -+ rs_table[line].baud_base = base_baud; -+ rs_table[line].dev = dev; -+ } -+} -+#endif /* ENABLE_SERIAL_PCI || ENABLE_SERIAL_PNP */ -+ -+#ifdef ENABLE_SERIAL_PCI -+/* -+ * 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 __devinit -+pci_plx9050_fn(struct pci_dev *dev, struct pci_board *board, int enable) -+{ -+ u8 data, *p, irq_config; -+ int pci_config; -+ -+ irq_config = 0x41; -+ pci_config = PCI_COMMAND_MEMORY; -+ if (dev->vendor == PCI_VENDOR_ID_PANACOM) -+ 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; -+ pci_config = PCI_COMMAND_MEMORY | PCI_COMMAND_IO; -+ } -+ -+ pci_read_config_byte(dev, PCI_COMMAND, &data); -+ -+ if (enable) -+ pci_write_config_byte(dev, PCI_COMMAND, -+ data | pci_config); -+ -+ /* enable/disable interrupts */ -+ p = ioremap(pci_resource_start(dev, 0), 0x80); -+ writel(enable ? irq_config : 0x00, (unsigned long)p + 0x4c); -+ iounmap(p); -+ -+ if (!enable) -+ pci_write_config_byte(dev, PCI_COMMAND, -+ data & ~pci_config); -+ return 0; -+} -+ -+ -+/* -+ * SIIG serial cards have an PCI interface chip which also controls -+ * the UART clocking frequency. Each UART can be clocked independently -+ * (except cards equiped 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@mail.tp.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. -+ * -+ * SIIG initialization functions exported for use by parport_serial.c module. -+ */ -+ -+#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) -+ -+int __devinit -+pci_siig10x_fn(struct pci_dev *dev, struct pci_board *board, int enable) -+{ -+ u16 data, *p; -+ -+ if (!enable) return 0; -+ -+ p = ioremap(pci_resource_start(dev, 0), 0x80); -+ -+ 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; -+ } -+ -+ writew(readw((unsigned long) p + 0x28) & data, (unsigned long) p + 0x28); -+ iounmap(p); -+ return 0; -+} -+EXPORT_SYMBOL(pci_siig10x_fn); -+ -+#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) -+ -+int __devinit -+pci_siig20x_fn(struct pci_dev *dev, struct pci_board *board, int enable) -+{ -+ u8 data; -+ -+ if (!enable) return 0; -+ -+ /* 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; -+} -+EXPORT_SYMBOL(pci_siig20x_fn); -+ -+/* Added for EKF Intel i960 serial boards */ -+static int __devinit -+pci_inteli960ni_fn(struct pci_dev *dev, -+ struct pci_board *board, -+ int enable) -+{ -+ unsigned long oldval; -+ -+ if (!(pci_get_subdevice(dev) & 0x1000)) -+ return(-1); -+ -+ if (!enable) /* is there something to deinit? */ -+ return(0); -+ -+#ifdef SERIAL_DEBUG_PCI -+ printk(KERN_DEBUG " Subsystem ID %lx (intel 960)\n", -+ (unsigned long) board->subdevice); -+#endif -+ /* is firmware started? */ -+ pci_read_config_dword(dev, 0x44, (void*) &oldval); -+ if (oldval == 0x00001000L) { /* RESET value */ -+ printk(KERN_DEBUG "Local i960 firmware missing"); -+ return(-1); -+ } -+ return(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 unsigned short timedia_single_port[] = { -+ 0x4025, 0x4027, 0x4028, 0x5025, 0x5027, 0 }; -+static 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 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 unsigned short timedia_eight_port[] = { -+ 0x4065, 0x4066, 0x5065, 0x5066, 0x8166, 0x9066, 0x9166, -+ 0x9167, 0x9168, 0xA066, 0xA167, 0xA168, 0 }; -+static struct timedia_struct { -+ int num; -+ unsigned short *ids; -+} timedia_data[] = { -+ { 1, timedia_single_port }, -+ { 2, timedia_dual_port }, -+ { 4, timedia_quad_port }, -+ { 8, timedia_eight_port }, -+ { 0, 0 } -+}; -+ -+static int __devinit -+pci_timedia_fn(struct pci_dev *dev, struct pci_board *board, int enable) -+{ -+ int i, j; -+ unsigned short *ids; -+ -+ if (!enable) -+ return 0; -+ -+ for (i=0; timedia_data[i].num; i++) { -+ ids = timedia_data[i].ids; -+ for (j=0; ids[j]; j++) { -+ if (pci_get_subdevice(dev) == ids[j]) { -+ board->num_ports = timedia_data[i].num; -+ return 0; -+ } -+ } -+ } -+ return 0; -+} -+ -+/* -+ * 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 __devinit -+pci_hp_diva(struct pci_dev *dev, struct pci_board *board, int enable) -+{ -+ if (!enable) -+ return 0; -+ -+ switch (dev->subsystem_device) { -+ case 0x1049: /* Prelude Diva 1 */ -+ case 0x1223: /* Superdome */ -+ case 0x1226: /* Keystone */ -+ case 0x1282: /* Everest / Longs Peak */ -+ board->num_ports = 3; -+ break; -+ case 0x104A: /* Prelude Diva 2 */ -+ board->num_ports = 2; -+ break; -+ case 0x104B: /* Maestro */ -+ board->num_ports = 4; -+ break; -+ case 0x1227: /* Powerbar */ -+ board->num_ports = 1; -+ break; -+ } -+ -+ return 0; -+} -+ -+static int __devinit -+pci_xircom_fn(struct pci_dev *dev, struct pci_board *board, int enable) -+{ -+ __set_current_state(TASK_UNINTERRUPTIBLE); -+ schedule_timeout(HZ/10); -+ return 0; -+} -+ -+/* -+ * 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. -+ */ -+enum pci_board_num_t { -+ pbn_b0_1_115200, -+ pbn_default = 0, -+ -+ pbn_b0_2_115200, -+ pbn_b0_4_115200, -+ -+ pbn_b0_1_921600, -+ pbn_b0_2_921600, -+ pbn_b0_4_921600, -+ -+ pbn_b0_bt_1_115200, -+ pbn_b0_bt_2_115200, -+ pbn_b0_bt_1_460800, -+ pbn_b0_bt_2_460800, -+ pbn_b0_bt_2_921600, -+ -+ pbn_b1_1_115200, -+ pbn_b1_2_115200, -+ pbn_b1_4_115200, -+ pbn_b1_8_115200, -+ -+ pbn_b1_2_921600, -+ pbn_b1_4_921600, -+ pbn_b1_8_921600, -+ -+ pbn_b1_2_1382400, -+ pbn_b1_4_1382400, -+ pbn_b1_8_1382400, -+ -+ pbn_b2_1_115200, -+ pbn_b2_8_115200, -+ pbn_b2_4_460800, -+ pbn_b2_8_460800, -+ pbn_b2_16_460800, -+ pbn_b2_4_921600, -+ pbn_b2_8_921600, -+ -+ pbn_b2_bt_1_115200, -+ pbn_b2_bt_2_115200, -+ pbn_b2_bt_4_115200, -+ pbn_b2_bt_2_921600, -+ -+ pbn_panacom, -+ pbn_panacom2, -+ pbn_panacom4, -+ pbn_plx_romulus, -+ pbn_oxsemi, -+ pbn_timedia, -+ pbn_intel_i960, -+ pbn_sgi_ioc3, -+ pbn_hp_diva, -+#ifdef CONFIG_DDB5074 -+ pbn_nec_nile4, -+#endif -+ -+ pbn_dci_pccom4, -+ pbn_dci_pccom8, -+ -+ pbn_xircom_combo, -+ -+ pbn_siig10x_0, -+ pbn_siig10x_1, -+ pbn_siig10x_2, -+ pbn_siig10x_4, -+ pbn_siig20x_0, -+ pbn_siig20x_2, -+ pbn_siig20x_4, -+ -+ pbn_computone_4, -+ pbn_computone_6, -+ pbn_computone_8, -+}; -+ -+static struct pci_board pci_boards[] __devinitdata = { -+ /* -+ * PCI Flags, Number of Ports, Base (Maximum) Baud Rate, -+ * Offset to get to next UART's registers, -+ * Register shift to use for memory-mapped I/O, -+ * Initialization function, first UART offset -+ */ -+ -+ /* Generic serial board, pbn_b0_1_115200, pbn_default */ -+ { SPCI_FL_BASE0, 1, 115200 }, /* pbn_b0_1_115200, -+ pbn_default */ -+ -+ { SPCI_FL_BASE0, 2, 115200 }, /* pbn_b0_2_115200 */ -+ { SPCI_FL_BASE0, 4, 115200 }, /* pbn_b0_4_115200 */ -+ -+ { SPCI_FL_BASE0, 1, 921600 }, /* pbn_b0_1_921600 */ -+ { SPCI_FL_BASE0, 2, 921600 }, /* pbn_b0_2_921600 */ -+ { SPCI_FL_BASE0, 4, 921600 }, /* pbn_b0_4_921600 */ -+ -+ { SPCI_FL_BASE0 | SPCI_FL_BASE_TABLE, 1, 115200 }, /* pbn_b0_bt_1_115200 */ -+ { SPCI_FL_BASE0 | SPCI_FL_BASE_TABLE, 2, 115200 }, /* pbn_b0_bt_2_115200 */ -+ { SPCI_FL_BASE0 | SPCI_FL_BASE_TABLE, 1, 460800 }, /* pbn_b0_bt_1_460800 */ -+ { SPCI_FL_BASE0 | SPCI_FL_BASE_TABLE, 2, 460800 }, /* pbn_b0_bt_2_460800 */ -+ { SPCI_FL_BASE0 | SPCI_FL_BASE_TABLE, 2, 921600 }, /* pbn_b0_bt_2_921600 */ -+ -+ { SPCI_FL_BASE1, 1, 115200 }, /* pbn_b1_1_115200 */ -+ { SPCI_FL_BASE1, 2, 115200 }, /* pbn_b1_2_115200 */ -+ { SPCI_FL_BASE1, 4, 115200 }, /* pbn_b1_4_115200 */ -+ { SPCI_FL_BASE1, 8, 115200 }, /* pbn_b1_8_115200 */ -+ -+ { SPCI_FL_BASE1, 2, 921600 }, /* pbn_b1_2_921600 */ -+ { SPCI_FL_BASE1, 4, 921600 }, /* pbn_b1_4_921600 */ -+ { SPCI_FL_BASE1, 8, 921600 }, /* pbn_b1_8_921600 */ -+ -+ { SPCI_FL_BASE1, 2, 1382400 }, /* pbn_b1_2_1382400 */ -+ { SPCI_FL_BASE1, 4, 1382400 }, /* pbn_b1_4_1382400 */ -+ { SPCI_FL_BASE1, 8, 1382400 }, /* pbn_b1_8_1382400 */ -+ -+ { SPCI_FL_BASE2, 1, 115200 }, /* pbn_b2_1_115200 */ -+ { SPCI_FL_BASE2, 8, 115200 }, /* pbn_b2_8_115200 */ -+ { SPCI_FL_BASE2, 4, 460800 }, /* pbn_b2_4_460800 */ -+ { SPCI_FL_BASE2, 8, 460800 }, /* pbn_b2_8_460800 */ -+ { SPCI_FL_BASE2, 16, 460800 }, /* pbn_b2_16_460800 */ -+ { SPCI_FL_BASE2, 4, 921600 }, /* pbn_b2_4_921600 */ -+ { SPCI_FL_BASE2, 8, 921600 }, /* pbn_b2_8_921600 */ -+ -+ { SPCI_FL_BASE2 | SPCI_FL_BASE_TABLE, 1, 115200 }, /* pbn_b2_bt_1_115200 */ -+ { SPCI_FL_BASE2 | SPCI_FL_BASE_TABLE, 2, 115200 }, /* pbn_b2_bt_2_115200 */ -+ { SPCI_FL_BASE2 | SPCI_FL_BASE_TABLE, 4, 115200 }, /* pbn_b2_bt_4_115200 */ -+ { SPCI_FL_BASE2 | SPCI_FL_BASE_TABLE, 2, 921600 }, /* pbn_b2_bt_2_921600 */ -+ -+ { SPCI_FL_BASE2, 2, 921600, /* IOMEM */ /* pbn_panacom */ -+ 0x400, 7, pci_plx9050_fn }, -+ { SPCI_FL_BASE2 | SPCI_FL_BASE_TABLE, 2, 921600, /* pbn_panacom2 */ -+ 0x400, 7, pci_plx9050_fn }, -+ { SPCI_FL_BASE2 | SPCI_FL_BASE_TABLE, 4, 921600, /* pbn_panacom4 */ -+ 0x400, 7, pci_plx9050_fn }, -+ { SPCI_FL_BASE2, 4, 921600, /* pbn_plx_romulus */ -+ 0x20, 2, pci_plx9050_fn, 0x03 }, -+ /* This board uses the size of PCI Base region 0 to -+ * signal now many ports are available */ -+ { SPCI_FL_BASE0 | SPCI_FL_REGION_SZ_CAP, 32, 115200 }, /* pbn_oxsemi */ -+ { SPCI_FL_BASE_TABLE, 1, 921600, /* pbn_timedia */ -+ 0, 0, pci_timedia_fn }, -+ /* EKF addition for i960 Boards form EKF with serial port */ -+ { SPCI_FL_BASE0, 32, 921600, /* max 256 ports */ /* pbn_intel_i960 */ -+ 8<<2, 2, pci_inteli960ni_fn, 0x10000}, -+ { SPCI_FL_BASE0 | SPCI_FL_IRQRESOURCE, /* pbn_sgi_ioc3 */ -+ 1, 458333, 0, 0, 0, 0x20178 }, -+ { SPCI_FL_BASE0, 5, 115200, 8, 0, pci_hp_diva, 0}, /* pbn_hp_diva */ -+#ifdef CONFIG_DDB5074 -+ /* -+ * NEC Vrc-5074 (Nile 4) builtin UART. -+ * Conditionally compiled in since this is a motherboard device. -+ */ -+ { SPCI_FL_BASE0, 1, 520833, /* pbn_nec_nile4 */ -+ 64, 3, NULL, 0x300 }, -+#endif -+ -+ {SPCI_FL_BASE3, 4, 115200, 8}, /* pbn_dci_pccom4 */ -+ {SPCI_FL_BASE3, 8, 115200, 8}, /* pbn_dci_pccom8 */ -+ -+ { SPCI_FL_BASE0, 1, 115200, /* pbn_xircom_combo */ -+ 0, 0, pci_xircom_fn }, -+ -+ { SPCI_FL_BASE2, 1, 460800, /* pbn_siig10x_0 */ -+ 0, 0, pci_siig10x_fn }, -+ { SPCI_FL_BASE2, 1, 921600, /* pbn_siig10x_1 */ -+ 0, 0, pci_siig10x_fn }, -+ { SPCI_FL_BASE2 | SPCI_FL_BASE_TABLE, 2, 921600, /* pbn_siig10x_2 */ -+ 0, 0, pci_siig10x_fn }, -+ { SPCI_FL_BASE2 | SPCI_FL_BASE_TABLE, 4, 921600, /* pbn_siig10x_4 */ -+ 0, 0, pci_siig10x_fn }, -+ { SPCI_FL_BASE0, 1, 921600, /* pbn_siix20x_0 */ -+ 0, 0, pci_siig20x_fn }, -+ { SPCI_FL_BASE0 | SPCI_FL_BASE_TABLE, 2, 921600, /* pbn_siix20x_2 */ -+ 0, 0, pci_siig20x_fn }, -+ { SPCI_FL_BASE0 | SPCI_FL_BASE_TABLE, 4, 921600, /* pbn_siix20x_4 */ -+ 0, 0, pci_siig20x_fn }, -+ -+ { SPCI_FL_BASE0, 4, 921600, /* IOMEM */ /* pbn_computone_4 */ -+ 0x40, 2, NULL, 0x200 }, -+ { SPCI_FL_BASE0, 6, 921600, /* IOMEM */ /* pbn_computone_6 */ -+ 0x40, 2, NULL, 0x200 }, -+ { SPCI_FL_BASE0, 8, 921600, /* IOMEM */ /* pbn_computone_8 */ -+ 0x40, 2, NULL, 0x200 }, -+}; -+ -+/* -+ * 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 __devinit serial_pci_guess_board(struct pci_dev *dev, -+ struct pci_board *board) -+{ -+ int num_iomem = 0, num_port = 0, first_port = -1; -+ int 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 1; -+ -+ for (i=0; i < 6; i++) { -+ if (IS_PCI_REGION_IOPORT(dev, i)) { -+ num_port++; -+ if (first_port == -1) -+ first_port = i; -+ } -+ if (IS_PCI_REGION_IOMEM(dev, i)) -+ num_iomem++; -+ } -+ -+ /* -+ * If there is 1 or 0 iomem regions, and exactly one port, use -+ * it. -+ */ -+ if (num_iomem <= 1 && num_port == 1) { -+ board->flags = first_port; -+ return 0; -+ } -+ return 1; -+} -+ -+static int __devinit serial_init_one(struct pci_dev *dev, -+ const struct pci_device_id *ent) -+{ -+ struct pci_board *board, tmp; -+ int rc; -+ -+ board = &pci_boards[ent->driver_data]; -+ -+ rc = pci_enable_device(dev); -+ if (rc) return rc; -+ -+ if (ent->driver_data == pbn_default && -+ serial_pci_guess_board(dev, board)) -+ return -ENODEV; -+ else if (serial_pci_guess_board(dev, &tmp) == 0) { -+ printk(KERN_INFO "Redundant entry in serial pci_table. " -+ "Please send the output of\n" -+ "lspci -vv, this message (%04x,%04x,%04x,%04x)\n" -+ "and the manufacturer and name of " -+ "serial board or modem board\n" -+ "to serial-pci-info@lists.sourceforge.net.\n", -+ dev->vendor, dev->device, -+ pci_get_subvendor(dev), pci_get_subdevice(dev)); -+ } -+ -+ start_pci_pnp_board(dev, board); -+ -+ return 0; -+} -+ -+static void __devexit serial_remove_one(struct pci_dev *dev) -+{ -+ int i; -+ -+ /* -+ * Iterate through all of the ports finding those that belong -+ * to this PCI device. -+ */ -+ for(i = 0; i < NR_PORTS; i++) { -+ if (rs_table[i].dev != dev) -+ continue; -+ unregister_serial(i); -+ rs_table[i].dev = 0; -+ } -+ /* -+ * Now execute any board-specific shutdown procedure -+ */ -+ for (i=0; i < NR_PCI_BOARDS; i++) { -+ struct pci_board_inst *brd = &serial_pci_board[i]; -+ -+ if (serial_pci_board[i].dev != dev) -+ continue; -+ if (brd->board.init_fn) -+ (brd->board.init_fn)(brd->dev, &brd->board, 0); -+ if (DEACTIVATE_FUNC(brd->dev)) -+ (DEACTIVATE_FUNC(brd->dev))(brd->dev); -+ serial_pci_board[i].dev = 0; -+ } -+} -+ -+ -+static struct pci_device_id serial_pci_tbl[] __devinitdata = { -+ { 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_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_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 }, -+ { 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_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 }, -+ /* 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 }, -+ { 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_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_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_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 }, -+ -+ /* 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 }, -+ -+ /* 3Com US Robotics 56k Voice Internal PCI model 5610 */ -+ { PCI_VENDOR_ID_USR, 0x1008, -+ PCI_ANY_ID, PCI_ANY_ID, }, -+ -+ /* Titan Electronic cards */ -+ { 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, -+ SPCI_FL_BASE1, 1, 921600 }, -+ { PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_200L, -+ PCI_ANY_ID, PCI_ANY_ID, -+ SPCI_FL_BASE1 | SPCI_FL_BASE_TABLE, 2, 921600 }, -+ /* The 400L and 800L have a custom hack in get_pci_port */ -+ { PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_400L, -+ PCI_ANY_ID, PCI_ANY_ID, -+ SPCI_FL_BASE_TABLE, 4, 921600 }, -+ { PCI_VENDOR_ID_TITAN, PCI_DEVICE_ID_TITAN_800L, -+ PCI_ANY_ID, PCI_ANY_ID, -+ SPCI_FL_BASE_TABLE, 8, 921600 }, -+ -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_10x_550, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig10x_0 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_10x_650, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig10x_0 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_10x_850, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig10x_0 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_10x_550, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig10x_2 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_10x_650, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig10x_2 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_10x_850, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig10x_2 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_10x_550, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig10x_4 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_10x_650, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig10x_4 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_10x_850, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig10x_4 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_20x_550, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig20x_0 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_20x_650, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig20x_0 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_1S_20x_850, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig20x_0 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_20x_550, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig20x_2 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_20x_650, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig20x_2 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_2S_20x_850, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig20x_2 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_20x_550, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig20x_4 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_20x_650, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig20x_4 }, -+ { PCI_VENDOR_ID_SIIG, PCI_DEVICE_ID_SIIG_4S_20x_850, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_siig20x_4 }, -+ -+ /* 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_timedia }, -+ -+ { 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_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 }, -+ -+ /* 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, 0x1960, -+ 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_xircom_combo }, -+ -+ /* -+ * 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_SAS, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_hp_diva }, -+ { PCI_VENDOR_ID_HP, 0x1290, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_b2_1_115200 }, -+ -+#ifdef CONFIG_DDB5074 -+ /* -+ * NEC Vrc-5074 (Nile 4) builtin UART. -+ * Conditionally compiled in since this is a motherboard device. -+ */ -+ { PCI_VENDOR_ID_NEC, PCI_DEVICE_ID_NEC_NILE4, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_nec_nile4 }, -+#endif -+ -+ { PCI_VENDOR_ID_DCI, PCI_DEVICE_ID_DCI_PCCOM4, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_dci_pccom4 }, -+ { PCI_VENDOR_ID_DCI, PCI_DEVICE_ID_DCI_PCCOM8, -+ PCI_ANY_ID, PCI_ANY_ID, 0, 0, -+ pbn_dci_pccom8 }, -+ -+ { PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, -+ PCI_CLASS_COMMUNICATION_SERIAL << 8, 0xffff00, }, -+ { PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, PCI_ANY_ID, -+ PCI_CLASS_COMMUNICATION_MODEM << 8, 0xffff00, }, -+ { 0, } -+}; -+ -+MODULE_DEVICE_TABLE(pci, serial_pci_tbl); -+ -+static struct pci_driver serial_pci_driver = { -+ name: "serial", -+ probe: serial_init_one, -+ remove: __devexit_p(serial_remove_one), -+ id_table: serial_pci_tbl, -+}; -+ -+ -+/* -+ * Query PCI space for known serial boards -+ * If found, add them to the PCI device space in rs_table[] -+ * -+ * Accept a maximum of eight boards -+ * -+ */ -+static void __devinit probe_serial_pci(void) -+{ -+#ifdef SERIAL_DEBUG_PCI -+ printk(KERN_DEBUG "Entered probe_serial_pci()\n"); -+#endif -+ -+ /* Register call PCI serial devices. Null out -+ * the driver name upon failure, as a signal -+ * not to attempt to unregister the driver later -+ */ -+ if (pci_module_init (&serial_pci_driver) != 0) -+ serial_pci_driver.name = ""; -+ -+#ifdef SERIAL_DEBUG_PCI -+ printk(KERN_DEBUG "Leaving probe_serial_pci() (probe finished)\n"); -+#endif -+ return; -+} -+ -+#endif /* ENABLE_SERIAL_PCI */ -+ -+#ifdef ENABLE_SERIAL_PNP -+ -+struct pnp_board { -+ unsigned short vendor; -+ unsigned short device; -+}; -+ -+static struct pnp_board pnp_devices[] __devinitdata = { -+ /* Archtek America Corp. */ -+ /* Archtek SmartLink Modem 3334BT Plug & Play */ -+ { ISAPNP_VENDOR('A', 'A', 'C'), ISAPNP_DEVICE(0x000F) }, -+ /* Anchor Datacomm BV */ -+ /* SXPro 144 External Data Fax Modem Plug & Play */ -+ { ISAPNP_VENDOR('A', 'D', 'C'), ISAPNP_DEVICE(0x0001) }, -+ /* SXPro 288 External Data Fax Modem Plug & Play */ -+ { ISAPNP_VENDOR('A', 'D', 'C'), ISAPNP_DEVICE(0x0002) }, -+ /* Rockwell 56K ACF II Fax+Data+Voice Modem */ -+ { ISAPNP_VENDOR('A', 'K', 'Y'), ISAPNP_DEVICE(0x1021) }, -+ /* AZT3005 PnP SOUND DEVICE */ -+ { ISAPNP_VENDOR('A', 'Z', 'T'), ISAPNP_DEVICE(0x4001) }, -+ /* Best Data Products Inc. Smart One 336F PnP Modem */ -+ { ISAPNP_VENDOR('B', 'D', 'P'), ISAPNP_DEVICE(0x3336) }, -+ /* Boca Research */ -+ /* Boca Complete Ofc Communicator 14.4 Data-FAX */ -+ { ISAPNP_VENDOR('B', 'R', 'I'), ISAPNP_DEVICE(0x0A49) }, -+ /* Boca Research 33,600 ACF Modem */ -+ { ISAPNP_VENDOR('B', 'R', 'I'), ISAPNP_DEVICE(0x1400) }, -+ /* Boca 33.6 Kbps Internal FD34FSVD */ -+ { ISAPNP_VENDOR('B', 'R', 'I'), ISAPNP_DEVICE(0x3400) }, -+ /* Boca 33.6 Kbps Internal FD34FSVD */ -+ { ISAPNP_VENDOR('B', 'R', 'I'), ISAPNP_DEVICE(0x0A49) }, -+ /* Best Data Products Inc. Smart One 336F PnP Modem */ -+ { ISAPNP_VENDOR('B', 'D', 'P'), ISAPNP_DEVICE(0x3336) }, -+ /* Computer Peripherals Inc */ -+ /* EuroViVa CommCenter-33.6 SP PnP */ -+ { ISAPNP_VENDOR('C', 'P', 'I'), ISAPNP_DEVICE(0x4050) }, -+ /* Creative Labs */ -+ /* Creative Labs Phone Blaster 28.8 DSVD PnP Voice */ -+ { ISAPNP_VENDOR('C', 'T', 'L'), ISAPNP_DEVICE(0x3001) }, -+ /* Creative Labs Modem Blaster 28.8 DSVD PnP Voice */ -+ { ISAPNP_VENDOR('C', 'T', 'L'), ISAPNP_DEVICE(0x3011) }, -+ /* Creative */ -+ /* Creative Modem Blaster Flash56 DI5601-1 */ -+ { ISAPNP_VENDOR('D', 'M', 'B'), ISAPNP_DEVICE(0x1032) }, -+ /* Creative Modem Blaster V.90 DI5660 */ -+ { ISAPNP_VENDOR('D', 'M', 'B'), ISAPNP_DEVICE(0x2001) }, -+ /* FUJITSU */ -+ /* Fujitsu 33600 PnP-I2 R Plug & Play */ -+ { ISAPNP_VENDOR('F', 'U', 'J'), ISAPNP_DEVICE(0x0202) }, -+ /* Fujitsu FMV-FX431 Plug & Play */ -+ { ISAPNP_VENDOR('F', 'U', 'J'), ISAPNP_DEVICE(0x0205) }, -+ /* Fujitsu 33600 PnP-I4 R Plug & Play */ -+ { ISAPNP_VENDOR('F', 'U', 'J'), ISAPNP_DEVICE(0x0206) }, -+ /* Fujitsu Fax Voice 33600 PNP-I5 R Plug & Play */ -+ { ISAPNP_VENDOR('F', 'U', 'J'), ISAPNP_DEVICE(0x0209) }, -+ /* Archtek America Corp. */ -+ /* Archtek SmartLink Modem 3334BT Plug & Play */ -+ { ISAPNP_VENDOR('G', 'V', 'C'), ISAPNP_DEVICE(0x000F) }, -+ /* Hayes */ -+ /* Hayes Optima 288 V.34-V.FC + FAX + Voice Plug & Play */ -+ { ISAPNP_VENDOR('H', 'A', 'Y'), ISAPNP_DEVICE(0x0001) }, -+ /* Hayes Optima 336 V.34 + FAX + Voice PnP */ -+ { ISAPNP_VENDOR('H', 'A', 'Y'), ISAPNP_DEVICE(0x000C) }, -+ /* Hayes Optima 336B V.34 + FAX + Voice PnP */ -+ { ISAPNP_VENDOR('H', 'A', 'Y'), ISAPNP_DEVICE(0x000D) }, -+ /* Hayes Accura 56K Ext Fax Modem PnP */ -+ { ISAPNP_VENDOR('H', 'A', 'Y'), ISAPNP_DEVICE(0x5670) }, -+ /* Hayes Accura 56K Ext Fax Modem PnP */ -+ { ISAPNP_VENDOR('H', 'A', 'Y'), ISAPNP_DEVICE(0x5674) }, -+ /* Hayes Accura 56K Fax Modem PnP */ -+ { ISAPNP_VENDOR('H', 'A', 'Y'), ISAPNP_DEVICE(0x5675) }, -+ /* Hayes 288, V.34 + FAX */ -+ { ISAPNP_VENDOR('H', 'A', 'Y'), ISAPNP_DEVICE(0xF000) }, -+ /* Hayes Optima 288 V.34 + FAX + Voice, Plug & Play */ -+ { ISAPNP_VENDOR('H', 'A', 'Y'), ISAPNP_DEVICE(0xF001) }, -+ /* IBM */ -+ /* IBM Thinkpad 701 Internal Modem Voice */ -+ { ISAPNP_VENDOR('I', 'B', 'M'), ISAPNP_DEVICE(0x0033) }, -+ /* Intertex */ -+ /* Intertex 28k8 33k6 Voice EXT PnP */ -+ { ISAPNP_VENDOR('I', 'X', 'D'), ISAPNP_DEVICE(0xC801) }, -+ /* Intertex 33k6 56k Voice EXT PnP */ -+ { ISAPNP_VENDOR('I', 'X', 'D'), ISAPNP_DEVICE(0xC901) }, -+ /* Intertex 28k8 33k6 Voice SP EXT PnP */ -+ { ISAPNP_VENDOR('I', 'X', 'D'), ISAPNP_DEVICE(0xD801) }, -+ /* Intertex 33k6 56k Voice SP EXT PnP */ -+ { ISAPNP_VENDOR('I', 'X', 'D'), ISAPNP_DEVICE(0xD901) }, -+ /* Intertex 28k8 33k6 Voice SP INT PnP */ -+ { ISAPNP_VENDOR('I', 'X', 'D'), ISAPNP_DEVICE(0xF401) }, -+ /* Intertex 28k8 33k6 Voice SP EXT PnP */ -+ { ISAPNP_VENDOR('I', 'X', 'D'), ISAPNP_DEVICE(0xF801) }, -+ /* Intertex 33k6 56k Voice SP EXT PnP */ -+ { ISAPNP_VENDOR('I', 'X', 'D'), ISAPNP_DEVICE(0xF901) }, -+ /* Kortex International */ -+ /* KORTEX 28800 Externe PnP */ -+ { ISAPNP_VENDOR('K', 'O', 'R'), ISAPNP_DEVICE(0x4522) }, -+ /* KXPro 33.6 Vocal ASVD PnP */ -+ { ISAPNP_VENDOR('K', 'O', 'R'), ISAPNP_DEVICE(0xF661) }, -+ /* Lasat */ -+ /* LASAT Internet 33600 PnP */ -+ { ISAPNP_VENDOR('L', 'A', 'S'), ISAPNP_DEVICE(0x4040) }, -+ /* Lasat Safire 560 PnP */ -+ { ISAPNP_VENDOR('L', 'A', 'S'), ISAPNP_DEVICE(0x4540) }, -+ /* Lasat Safire 336 PnP */ -+ { ISAPNP_VENDOR('L', 'A', 'S'), ISAPNP_DEVICE(0x5440) }, -+ /* Microcom, Inc. */ -+ /* Microcom TravelPorte FAST V.34 Plug & Play */ -+ { ISAPNP_VENDOR('M', 'N', 'P'), ISAPNP_DEVICE(0x281) }, -+ /* Microcom DeskPorte V.34 FAST or FAST+ Plug & Play */ -+ { ISAPNP_VENDOR('M', 'N', 'P'), ISAPNP_DEVICE(0x0336) }, -+ /* Microcom DeskPorte FAST EP 28.8 Plug & Play */ -+ { ISAPNP_VENDOR('M', 'N', 'P'), ISAPNP_DEVICE(0x0339) }, -+ /* Microcom DeskPorte 28.8P Plug & Play */ -+ { ISAPNP_VENDOR('M', 'N', 'P'), ISAPNP_DEVICE(0x0342) }, -+ /* Microcom DeskPorte FAST ES 28.8 Plug & Play */ -+ { ISAPNP_VENDOR('M', 'N', 'P'), ISAPNP_DEVICE(0x0500) }, -+ /* Microcom DeskPorte FAST ES 28.8 Plug & Play */ -+ { ISAPNP_VENDOR('M', 'N', 'P'), ISAPNP_DEVICE(0x0501) }, -+ /* Microcom DeskPorte 28.8S Internal Plug & Play */ -+ { ISAPNP_VENDOR('M', 'N', 'P'), ISAPNP_DEVICE(0x0502) }, -+ /* Motorola */ -+ /* Motorola BitSURFR Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1105) }, -+ /* Motorola TA210 Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1111) }, -+ /* Motorola HMTA 200 (ISDN) Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1114) }, -+ /* Motorola BitSURFR Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1115) }, -+ /* Motorola Lifestyle 28.8 Internal */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1190) }, -+ /* Motorola V.3400 Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1501) }, -+ /* Motorola Lifestyle 28.8 V.34 Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1502) }, -+ /* Motorola Power 28.8 V.34 Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1505) }, -+ /* Motorola ModemSURFR External 28.8 Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1509) }, -+ /* Motorola Premier 33.6 Desktop Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x150A) }, -+ /* Motorola VoiceSURFR 56K External PnP */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x150F) }, -+ /* Motorola ModemSURFR 56K External PnP */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1510) }, -+ /* Motorola ModemSURFR 56K Internal PnP */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1550) }, -+ /* Motorola ModemSURFR Internal 28.8 Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1560) }, -+ /* Motorola Premier 33.6 Internal Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x1580) }, -+ /* Motorola OnlineSURFR 28.8 Internal Plug & Play */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x15B0) }, -+ /* Motorola VoiceSURFR 56K Internal PnP */ -+ { ISAPNP_VENDOR('M', 'O', 'T'), ISAPNP_DEVICE(0x15F0) }, -+ /* Com 1 */ -+ /* Deskline K56 Phone System PnP */ -+ { ISAPNP_VENDOR('M', 'V', 'X'), ISAPNP_DEVICE(0x00A1) }, -+ /* PC Rider K56 Phone System PnP */ -+ { ISAPNP_VENDOR('M', 'V', 'X'), ISAPNP_DEVICE(0x00F2) }, -+ /* Pace 56 Voice Internal Plug & Play Modem */ -+ { ISAPNP_VENDOR('P', 'M', 'C'), ISAPNP_DEVICE(0x2430) }, -+ /* Generic */ -+ /* Generic standard PC COM port */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0x0500) }, -+ /* Generic 16550A-compatible COM port */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0x0501) }, -+ /* Compaq 14400 Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC000) }, -+ /* Compaq 2400/9600 Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC001) }, -+ /* Dial-Up Networking Serial Cable between 2 PCs */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC031) }, -+ /* Dial-Up Networking Parallel Cable between 2 PCs */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC032) }, -+ /* Standard 9600 bps Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC100) }, -+ /* Standard 14400 bps Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC101) }, -+ /* Standard 28800 bps Modem*/ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC102) }, -+ /* Standard Modem*/ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC103) }, -+ /* Standard 9600 bps Modem*/ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC104) }, -+ /* Standard 14400 bps Modem*/ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC105) }, -+ /* Standard 28800 bps Modem*/ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC106) }, -+ /* Standard Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC107) }, -+ /* Standard 9600 bps Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC108) }, -+ /* Standard 14400 bps Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC109) }, -+ /* Standard 28800 bps Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC10A) }, -+ /* Standard Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC10B) }, -+ /* Standard 9600 bps Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC10C) }, -+ /* Standard 14400 bps Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC10D) }, -+ /* Standard 28800 bps Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC10E) }, -+ /* Standard Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0xC10F) }, -+ /* Standard PCMCIA Card Modem */ -+ { ISAPNP_VENDOR('P', 'N', 'P'), ISAPNP_DEVICE(0x2000) }, -+ /* Rockwell */ -+ /* Modular Technology */ -+ /* Rockwell 33.6 DPF Internal PnP */ -+ /* Modular Technology 33.6 Internal PnP */ -+ { ISAPNP_VENDOR('R', 'O', 'K'), ISAPNP_DEVICE(0x0030) }, -+ /* Kortex International */ -+ /* KORTEX 14400 Externe PnP */ -+ { ISAPNP_VENDOR('R', 'O', 'K'), ISAPNP_DEVICE(0x0100) }, -+ /* Viking Components, Inc */ -+ /* Viking 28.8 INTERNAL Fax+Data+Voice PnP */ -+ { ISAPNP_VENDOR('R', 'O', 'K'), ISAPNP_DEVICE(0x4920) }, -+ /* Rockwell */ -+ /* British Telecom */ -+ /* Modular Technology */ -+ /* Rockwell 33.6 DPF External PnP */ -+ /* BT Prologue 33.6 External PnP */ -+ /* Modular Technology 33.6 External PnP */ -+ { ISAPNP_VENDOR('R', 'S', 'S'), ISAPNP_DEVICE(0x00A0) }, -+ /* Viking 56K FAX INT */ -+ { ISAPNP_VENDOR('R', 'S', 'S'), ISAPNP_DEVICE(0x0262) }, -+ /* SupraExpress 28.8 Data/Fax PnP modem */ -+ { ISAPNP_VENDOR('S', 'U', 'P'), ISAPNP_DEVICE(0x1310) }, -+ /* SupraExpress 33.6 Data/Fax PnP modem */ -+ { ISAPNP_VENDOR('S', 'U', 'P'), ISAPNP_DEVICE(0x1421) }, -+ /* SupraExpress 33.6 Data/Fax PnP modem */ -+ { ISAPNP_VENDOR('S', 'U', 'P'), ISAPNP_DEVICE(0x1590) }, -+ /* SupraExpress 33.6 Data/Fax PnP modem */ -+ { ISAPNP_VENDOR('S', 'U', 'P'), ISAPNP_DEVICE(0x1760) }, -+ /* Phoebe Micro */ -+ /* Phoebe Micro 33.6 Data Fax 1433VQH Plug & Play */ -+ { ISAPNP_VENDOR('T', 'E', 'X'), ISAPNP_DEVICE(0x0011) }, -+ /* Archtek America Corp. */ -+ /* Archtek SmartLink Modem 3334BT Plug & Play */ -+ { ISAPNP_VENDOR('U', 'A', 'C'), ISAPNP_DEVICE(0x000F) }, -+ /* 3Com Corp. */ -+ /* Gateway Telepath IIvi 33.6 */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x0000) }, -+ /* Sportster Vi 14.4 PnP FAX Voicemail */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x0004) }, -+ /* U.S. Robotics 33.6K Voice INT PnP */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x0006) }, -+ /* U.S. Robotics 33.6K Voice EXT PnP */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x0007) }, -+ /* U.S. Robotics 33.6K Voice INT PnP */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x2002) }, -+ /* U.S. Robotics 56K Voice INT PnP */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x2070) }, -+ /* U.S. Robotics 56K Voice EXT PnP */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x2080) }, -+ /* U.S. Robotics 56K FAX INT */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x3031) }, -+ /* U.S. Robotics 56K Voice INT PnP */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x3070) }, -+ /* U.S. Robotics 56K Voice EXT PnP */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x3080) }, -+ /* U.S. Robotics 56K Voice INT PnP */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x3090) }, -+ /* U.S. Robotics 56K Message */ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x9100) }, -+ /* U.S. Robotics 56K FAX EXT PnP*/ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x9160) }, -+ /* U.S. Robotics 56K FAX INT PnP*/ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x9170) }, -+ /* U.S. Robotics 56K Voice EXT PnP*/ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x9180) }, -+ /* U.S. Robotics 56K Voice INT PnP*/ -+ { ISAPNP_VENDOR('U', 'S', 'R'), ISAPNP_DEVICE(0x9190) }, -+ { 0, } -+}; -+ -+static inline void avoid_irq_share(struct pci_dev *dev) -+{ -+ int i, map = 0x1FF8; -+ struct serial_state *state = rs_table; -+ struct isapnp_irq *irq; -+ struct isapnp_resources *res = dev->sysdata; -+ -+ for (i = 0; i < NR_PORTS; i++) { -+ if (state->type != PORT_UNKNOWN) -+ clear_bit(state->irq, &map); -+ state++; -+ } -+ -+ for ( ; res; res = res->alt) -+ for(irq = res->irq; irq; irq = irq->next) -+ irq->map = map; -+} -+ -+static char *modem_names[] __devinitdata = { -+ "MODEM", "Modem", "modem", "FAX", "Fax", "fax", -+ "56K", "56k", "K56", "33.6", "28.8", "14.4", -+ "33,600", "28,800", "14,400", "33.600", "28.800", "14.400", -+ "33600", "28800", "14400", "V.90", "V.34", "V.32", 0 -+}; -+ -+static int __devinit check_name(char *name) -+{ -+ char **tmp = modem_names; -+ -+ while (*tmp) { -+ if (strstr(name, *tmp)) -+ return 1; -+ tmp++; -+ } -+ return 0; -+} -+ -+static inline int check_compatible_id(struct pci_dev *dev) -+{ -+ int i; -+ for (i = 0; i < DEVICE_COUNT_COMPATIBLE; i++) -+ if ((dev->vendor_compatible[i] == -+ ISAPNP_VENDOR('P', 'N', 'P')) && -+ (swab16(dev->device_compatible[i]) >= 0xc000) && -+ (swab16(dev->device_compatible[i]) <= 0xdfff)) -+ return 0; -+ return 1; -+} -+ -+/* -+ * Given a complete unknown ISA PnP device, try to use some heuristics to -+ * detect modems. Currently use such heuristic set: -+ * - dev->name or dev->bus->name must contain "modem" substring; -+ * - device must have only one IO region (8 byte long) with base adress -+ * 0x2e8, 0x3e8, 0x2f8 or 0x3f8. -+ * -+ * Such detection looks very ugly, but can detect at least some of numerous -+ * ISA PnP modems, alternatively we must hardcode all modems in pnp_devices[] -+ * table. -+ */ -+static int _INLINE_ serial_pnp_guess_board(struct pci_dev *dev, -+ struct pci_board *board) -+{ -+ struct isapnp_resources *res = (struct isapnp_resources *)dev->sysdata; -+ struct isapnp_resources *resa; -+ -+ if (!(check_name(dev->name) || check_name(dev->bus->name)) && -+ !(check_compatible_id(dev))) -+ return 1; -+ -+ if (!res || res->next) -+ return 1; -+ -+ for (resa = res->alt; resa; resa = resa->alt) { -+ struct isapnp_port *port; -+ for (port = res->port; port; port = port->next) -+ if ((port->size == 8) && -+ ((port->min == 0x2f8) || -+ (port->min == 0x3f8) || -+ (port->min == 0x2e8) || -+ (port->min == 0x3e8))) -+ return 0; -+ } -+ -+ return 1; -+} -+ -+static void __devinit probe_serial_pnp(void) -+{ -+ struct pci_dev *dev = NULL; -+ struct pnp_board *pnp_board; -+ struct pci_board board; -+ -+#ifdef SERIAL_DEBUG_PNP -+ printk("Entered probe_serial_pnp()\n"); -+#endif -+ if (!isapnp_present()) { -+#ifdef SERIAL_DEBUG_PNP -+ printk("Leaving probe_serial_pnp() (no isapnp)\n"); -+#endif -+ return; -+ } -+ -+ isapnp_for_each_dev(dev) { -+ if (dev->active) -+ continue; -+ -+ memset(&board, 0, sizeof(board)); -+ board.flags = SPCI_FL_BASE0 | SPCI_FL_PNPDEFAULT; -+ board.num_ports = 1; -+ board.base_baud = 115200; -+ -+ for (pnp_board = pnp_devices; pnp_board->vendor; pnp_board++) -+ if ((dev->vendor == pnp_board->vendor) && -+ (dev->device == pnp_board->device)) -+ break; -+ -+ if (pnp_board->vendor) { -+ /* Special case that's more efficient to hardcode */ -+ if ((pnp_board->vendor == ISAPNP_VENDOR('A', 'K', 'Y') && -+ pnp_board->device == ISAPNP_DEVICE(0x1021))) -+ board.flags |= SPCI_FL_NO_SHIRQ; -+ } else { -+ if (serial_pnp_guess_board(dev, &board)) -+ continue; -+ } -+ -+ if (board.flags & SPCI_FL_NO_SHIRQ) -+ avoid_irq_share(dev); -+ start_pci_pnp_board(dev, &board); -+ } -+ -+#ifdef SERIAL_DEBUG_PNP -+ printk("Leaving probe_serial_pnp() (probe finished)\n"); -+#endif -+ return; -+} -+ -+#endif /* ENABLE_SERIAL_PNP */ -+ -+/* -+ * The serial driver boot-time initialization code! -+ */ -+static int __init rs_init(void) -+{ -+ int i; -+ struct serial_state * state; -+ -+ init_bh(SERIAL_BH, do_serial_bh); -+ init_timer(&serial_timer); -+ serial_timer.function = rs_timer; -+ mod_timer(&serial_timer, jiffies + RS_STROBE_TIME); -+ -+ for (i = 0; i < NR_IRQS; i++) { -+ IRQ_ports[i] = 0; -+ IRQ_timeout[i] = 0; -+#ifdef CONFIG_SERIAL_MULTIPORT -+ memset(&rs_multiport[i], 0, -+ sizeof(struct rs_multiport_struct)); -+#endif -+ } -+ show_serial_version(); -+ -+ /* Initialize the tty_driver structure */ -+ -+ memset(&serial_driver, 0, sizeof(struct tty_driver)); -+ serial_driver.magic = TTY_DRIVER_MAGIC; -+#if (LINUX_VERSION_CODE > 0x20100) -+ serial_driver.driver_name = "serial"; -+#endif -+#if (LINUX_VERSION_CODE > 0x2032D && defined(CONFIG_DEVFS_FS)) -+ serial_driver.name = "tts/%d"; -+#else -+ serial_driver.name = "ttyS"; -+#endif -+ serial_driver.major = TTY_MAJOR; -+ serial_driver.minor_start = 64 + SERIAL_DEV_OFFSET; -+ serial_driver.name_base = SERIAL_DEV_OFFSET; -+ serial_driver.num = NR_PORTS; -+ serial_driver.type = TTY_DRIVER_TYPE_SERIAL; -+ serial_driver.subtype = SERIAL_TYPE_NORMAL; -+ serial_driver.init_termios = tty_std_termios; -+ serial_driver.init_termios.c_cflag = -+ B9600 | CS8 | CREAD | HUPCL | CLOCAL; -+ serial_driver.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS; -+ serial_driver.refcount = &serial_refcount; -+ serial_driver.table = serial_table; -+ serial_driver.termios = serial_termios; -+ serial_driver.termios_locked = serial_termios_locked; -+ -+ serial_driver.open = rs_open; -+ serial_driver.close = rs_close; -+ serial_driver.write = rs_write; -+ serial_driver.put_char = rs_put_char; -+ serial_driver.flush_chars = rs_flush_chars; -+ serial_driver.write_room = rs_write_room; -+ serial_driver.chars_in_buffer = rs_chars_in_buffer; -+ serial_driver.flush_buffer = rs_flush_buffer; -+ serial_driver.ioctl = rs_ioctl; -+ serial_driver.throttle = rs_throttle; -+ serial_driver.unthrottle = rs_unthrottle; -+ serial_driver.set_termios = rs_set_termios; -+ serial_driver.stop = rs_stop; -+ serial_driver.start = rs_start; -+ serial_driver.hangup = rs_hangup; -+#if (LINUX_VERSION_CODE >= 131394) /* Linux 2.1.66 */ -+ serial_driver.break_ctl = rs_break; -+#endif -+#if (LINUX_VERSION_CODE >= 131343) -+ serial_driver.send_xchar = rs_send_xchar; -+ serial_driver.wait_until_sent = rs_wait_until_sent; -+ serial_driver.read_proc = rs_read_proc; -+#endif -+ -+ /* -+ * The callout device is just like normal device except for -+ * major number and the subtype code. -+ */ -+ callout_driver = serial_driver; -+#if (LINUX_VERSION_CODE > 0x2032D && defined(CONFIG_DEVFS_FS)) -+ callout_driver.name = "cua/%d"; -+#else -+ callout_driver.name = "cua"; -+#endif -+ callout_driver.major = TTYAUX_MAJOR; -+ callout_driver.subtype = SERIAL_TYPE_CALLOUT; -+#if (LINUX_VERSION_CODE >= 131343) -+ callout_driver.read_proc = 0; -+ callout_driver.proc_entry = 0; -+#endif -+ -+ if (tty_register_driver(&serial_driver)) -+ panic("Couldn't register serial driver\n"); -+ if (tty_register_driver(&callout_driver)) -+ panic("Couldn't register callout driver\n"); -+ -+ for (i = 0, state = rs_table; i < NR_PORTS; i++,state++) { -+ state->magic = SSTATE_MAGIC; -+ state->line = i; -+ state->type = PORT_UNKNOWN; -+ state->custom_divisor = 0; -+ state->close_delay = 5*HZ/10; -+ state->closing_wait = 30*HZ; -+ state->callout_termios = callout_driver.init_termios; -+ state->normal_termios = serial_driver.init_termios; -+ state->icount.cts = state->icount.dsr = -+ state->icount.rng = state->icount.dcd = 0; -+ state->icount.rx = state->icount.tx = 0; -+ state->icount.frame = state->icount.parity = 0; -+ state->icount.overrun = state->icount.brk = 0; -+ state->irq = irq_cannonicalize(state->irq); -+ if (state->hub6) -+ state->io_type = SERIAL_IO_HUB6; -+ if (state->port && check_region(state->port,8)) -+ continue; -+#ifdef CONFIG_MCA -+ if ((state->flags & ASYNC_BOOT_ONLYMCA) && !MCA_bus) -+ continue; -+#endif -+ if (state->flags & ASYNC_BOOT_AUTOCONF) -+ autoconfig(state); -+ } -+ for (i = 0, state = rs_table; i < NR_PORTS; i++,state++) { -+ if (state->type == PORT_UNKNOWN) -+ continue; -+ if ( (state->flags & ASYNC_BOOT_AUTOCONF) -+ && (state->flags & ASYNC_AUTO_IRQ) -+ && (state->port != 0 || state->iomem_base != 0)) -+ state->irq = detect_uart_irq(state); -+ if (state->io_type == SERIAL_IO_MEM) { -+ printk(KERN_INFO"ttyS%02d%s at 0x%p (irq = %d) is a %s\n", -+ state->line + SERIAL_DEV_OFFSET, -+ (state->flags & ASYNC_FOURPORT) ? " FourPort" : "", -+ state->iomem_base, state->irq, -+ uart_config[state->type].name); -+ } -+ else { -+ printk(KERN_INFO "ttyS%02d%s at 0x%04lx (irq = %d) is a %s\n", -+ state->line + SERIAL_DEV_OFFSET, -+ (state->flags & ASYNC_FOURPORT) ? " FourPort" : "", -+ state->port, state->irq, -+ uart_config[state->type].name); -+ } -+ tty_register_devfs(&serial_driver, 0, -+ serial_driver.minor_start + state->line); -+ tty_register_devfs(&callout_driver, 0, -+ callout_driver.minor_start + state->line); -+ } -+#ifdef ENABLE_SERIAL_PCI -+ probe_serial_pci(); -+#endif -+#ifdef ENABLE_SERIAL_PNP -+ probe_serial_pnp(); -+#endif -+ return 0; -+} -+ -+/* -+ * This is for use by architectures that know their serial console -+ * attributes only at run time. Not to be invoked after rs_init(). -+ */ -+int __init early_serial_setup(struct serial_struct *req) -+{ -+ int i = req->line; -+ -+ if (i >= NR_IRQS) -+ return(-ENOENT); -+ rs_table[i].magic = 0; -+ rs_table[i].baud_base = req->baud_base; -+ rs_table[i].port = req->port; -+ if (HIGH_BITS_OFFSET) -+ rs_table[i].port += (unsigned long) req->port_high << -+ HIGH_BITS_OFFSET; -+ rs_table[i].irq = req->irq; -+ rs_table[i].flags = req->flags; -+ rs_table[i].close_delay = req->close_delay; -+ rs_table[i].io_type = req->io_type; -+ rs_table[i].hub6 = req->hub6; -+ rs_table[i].iomem_base = req->iomem_base; -+ rs_table[i].iomem_reg_shift = req->iomem_reg_shift; -+ rs_table[i].type = req->type; -+ rs_table[i].xmit_fifo_size = req->xmit_fifo_size; -+ rs_table[i].custom_divisor = req->custom_divisor; -+ rs_table[i].closing_wait = req->closing_wait; -+ return(0); -+} -+ -+/* -+ * register_serial and unregister_serial allows for 16x50 serial ports to be -+ * configured at run-time, to support PCMCIA modems. -+ */ -+ -+/** -+ * register_serial - configure a 16x50 serial port at runtime -+ * @req: request structure -+ * -+ * Configure the serial port specified by the request. If the -+ * port exists and is in use an error is returned. If the port -+ * is not currently in the table it is added. -+ * -+ * The port is then probed and if neccessary 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 register_serial(struct serial_struct *req) -+{ -+ int i; -+ unsigned long flags; -+ struct serial_state *state; -+ struct async_struct *info; -+ unsigned long port; -+ -+ port = req->port; -+ if (HIGH_BITS_OFFSET) -+ port += (unsigned long) req->port_high << HIGH_BITS_OFFSET; -+ -+ save_flags(flags); cli(); -+ for (i = 0; i < NR_PORTS; i++) { -+ if ((rs_table[i].port == port) && -+ (rs_table[i].iomem_base == req->iomem_base)) -+ break; -+ } -+#ifdef __i386__ -+ if (i == NR_PORTS) { -+ for (i = 4; i < NR_PORTS; i++) -+ if ((rs_table[i].type == PORT_UNKNOWN) && -+ (rs_table[i].count == 0)) -+ break; -+ } -+#endif -+ if (i == NR_PORTS) { -+ for (i = 0; i < NR_PORTS; i++) -+ if ((rs_table[i].type == PORT_UNKNOWN) && -+ (rs_table[i].count == 0)) -+ break; -+ } -+ if (i == NR_PORTS) { -+ restore_flags(flags); -+ return -1; -+ } -+ state = &rs_table[i]; -+ if (rs_table[i].count) { -+ restore_flags(flags); -+ printk("Couldn't configure serial #%d (port=%ld,irq=%d): " -+ "device already open\n", i, port, req->irq); -+ return -1; -+ } -+ state->irq = req->irq; -+ state->port = port; -+ state->flags = req->flags; -+ state->io_type = req->io_type; -+ state->iomem_base = req->iomem_base; -+ state->iomem_reg_shift = req->iomem_reg_shift; -+ if (req->baud_base) -+ state->baud_base = req->baud_base; -+ if ((info = state->info) != NULL) { -+ info->port = port; -+ info->flags = req->flags; -+ info->io_type = req->io_type; -+ info->iomem_base = req->iomem_base; -+ info->iomem_reg_shift = req->iomem_reg_shift; -+ } -+ autoconfig(state); -+ if (state->type == PORT_UNKNOWN) { -+ restore_flags(flags); -+ printk("register_serial(): autoconfig failed\n"); -+ return -1; -+ } -+ restore_flags(flags); -+ -+ if ((state->flags & ASYNC_AUTO_IRQ) && CONFIGURED_SERIAL_PORT(state)) -+ state->irq = detect_uart_irq(state); -+ -+ printk(KERN_INFO "ttyS%02d at %s 0x%04lx (irq = %d) is a %s\n", -+ state->line + SERIAL_DEV_OFFSET, -+ state->iomem_base ? "iomem" : "port", -+ state->iomem_base ? (unsigned long)state->iomem_base : -+ state->port, state->irq, uart_config[state->type].name); -+ tty_register_devfs(&serial_driver, 0, -+ serial_driver.minor_start + state->line); -+ tty_register_devfs(&callout_driver, 0, -+ callout_driver.minor_start + state->line); -+ return state->line + SERIAL_DEV_OFFSET; -+} -+ -+/** -+ * unregister_serial - deconfigure a 16x50 serial port -+ * @line: line to deconfigure -+ * -+ * The port specified is deconfigured and its resources are freed. Any -+ * user of the port is disconnected as if carrier was dropped. Line is -+ * the port number returned by register_serial(). -+ */ -+ -+void unregister_serial(int line) -+{ -+ unsigned long flags; -+ struct serial_state *state = &rs_table[line]; -+ -+ save_flags(flags); cli(); -+ if (state->info && state->info->tty) -+ tty_hangup(state->info->tty); -+ state->type = PORT_UNKNOWN; -+ printk(KERN_INFO "ttyS%02d unloaded\n", state->line); -+ /* These will be hidden, because they are devices that will no longer -+ * be available to the system. (ie, PCMCIA modems, once ejected) -+ */ -+ tty_unregister_devfs(&serial_driver, -+ serial_driver.minor_start + state->line); -+ tty_unregister_devfs(&callout_driver, -+ callout_driver.minor_start + state->line); -+ restore_flags(flags); -+} -+ -+static void __exit rs_fini(void) -+{ -+ unsigned long flags; -+ int e1, e2; -+ int i; -+ struct async_struct *info; -+ -+ /* printk("Unloading %s: version %s\n", serial_name, serial_version); */ -+ del_timer_sync(&serial_timer); -+ save_flags(flags); cli(); -+ remove_bh(SERIAL_BH); -+ if ((e1 = tty_unregister_driver(&serial_driver))) -+ printk("serial: failed to unregister serial driver (%d)\n", -+ e1); -+ if ((e2 = tty_unregister_driver(&callout_driver))) -+ printk("serial: failed to unregister callout driver (%d)\n", -+ e2); -+ restore_flags(flags); -+ -+ for (i = 0; i < NR_PORTS; i++) { -+ if ((info = rs_table[i].info)) { -+ rs_table[i].info = NULL; -+ kfree(info); -+ } -+ if ((rs_table[i].type != PORT_UNKNOWN) && rs_table[i].port) { -+#ifdef CONFIG_SERIAL_RSA -+ if (rs_table[i].type == PORT_RSA) -+ release_region(rs_table[i].port + -+ UART_RSA_BASE, 16); -+ else -+#endif -+ release_region(rs_table[i].port, 8); -+ } -+#if defined(ENABLE_SERIAL_PCI) || defined(ENABLE_SERIAL_PNP) -+ if (rs_table[i].iomem_base) -+ iounmap(rs_table[i].iomem_base); -+#endif -+ } -+#if defined(ENABLE_SERIAL_PCI) || defined(ENABLE_SERIAL_PNP) -+ for (i=0; i < NR_PCI_BOARDS; i++) { -+ struct pci_board_inst *brd = &serial_pci_board[i]; -+ -+ if (serial_pci_board[i].dev == 0) -+ continue; -+ if (brd->board.init_fn) -+ (brd->board.init_fn)(brd->dev, &brd->board, 0); -+ if (DEACTIVATE_FUNC(brd->dev)) -+ (DEACTIVATE_FUNC(brd->dev))(brd->dev); -+ } -+#endif -+ if (tmp_buf) { -+ unsigned long pg = (unsigned long) tmp_buf; -+ tmp_buf = NULL; -+ free_page(pg); -+ } -+ -+#ifdef ENABLE_SERIAL_PCI -+ if (serial_pci_driver.name[0]) -+ pci_unregister_driver (&serial_pci_driver); -+#endif -+} -+ -+module_init(rs_init); -+module_exit(rs_fini); -+MODULE_DESCRIPTION("Standard/generic (dumb) serial driver"); -+MODULE_AUTHOR("Theodore Ts'o <tytso@mit.edu>"); -+MODULE_LICENSE("GPL"); -+ -+ -+/* -+ * ------------------------------------------------------------ -+ * Serial console driver -+ * ------------------------------------------------------------ -+ */ -+#ifdef CONFIG_SERIAL_CONSOLE -+ -+#define BOTH_EMPTY (UART_LSR_TEMT | UART_LSR_THRE) -+ -+static struct async_struct async_sercons; -+ -+/* -+ * Wait for transmitter & holding register to empty -+ */ -+static inline void wait_for_xmitr(struct async_struct *info) -+{ -+ unsigned int status, tmout = 1000000; -+ -+ do { -+ status = serial_in(info, UART_LSR); -+ -+ if (status & UART_LSR_BI) -+ lsr_break_flag = UART_LSR_BI; -+ -+ if (--tmout == 0) -+ break; -+ } while((status & BOTH_EMPTY) != BOTH_EMPTY); -+ -+ /* Wait for flow control if necessary */ -+ if (info->flags & ASYNC_CONS_FLOW) { -+ tmout = 1000000; -+ while (--tmout && -+ ((serial_in(info, UART_MSR) & UART_MSR_CTS) == 0)); -+ } -+} -+ -+ -+/* -+ * Print a string to the serial port trying not to disturb -+ * any possible real use of the port... -+ * -+ * The console must be locked when we get here. -+ */ -+static void serial_console_write(struct console *co, const char *s, -+ unsigned count) -+{ -+ static struct async_struct *info = &async_sercons; -+ int ier; -+ unsigned i; -+ -+ /* -+ * First save the IER then disable the interrupts -+ */ -+ ier = serial_in(info, UART_IER); -+ serial_out(info, UART_IER, 0x00); -+ -+ /* -+ * Now, do each character -+ */ -+ for (i = 0; i < count; i++, s++) { -+ wait_for_xmitr(info); -+ -+ /* -+ * Send the character out. -+ * If a LF, also do CR... -+ */ -+ serial_out(info, UART_TX, *s); -+ if (*s == 10) { -+ wait_for_xmitr(info); -+ serial_out(info, UART_TX, 13); -+ } -+ } -+ -+ /* -+ * Finally, Wait for transmitter & holding register to empty -+ * and restore the IER -+ */ -+ wait_for_xmitr(info); -+ serial_out(info, UART_IER, ier); -+} -+ -+static kdev_t serial_console_device(struct console *c) -+{ -+ return MKDEV(TTY_MAJOR, 64 + c->index); -+} -+ -+/* -+ * Setup initial baud/bits/parity/flow control. We do two things here: -+ * - construct a cflag setting for the first rs_open() -+ * - initialize the serial port -+ * Return non-zero if we didn't find a serial port. -+ */ -+static int __init serial_console_setup(struct console *co, char *options) -+{ -+ static struct async_struct *info; -+ struct serial_state *state; -+ unsigned cval; -+ int baud = 9600; -+ int bits = 8; -+ int parity = 'n'; -+ int doflow = 0; -+ int cflag = CREAD | HUPCL | CLOCAL; -+ int quot = 0; -+ char *s; -+ -+ if (options) { -+ baud = simple_strtoul(options, NULL, 10); -+ s = options; -+ while(*s >= '0' && *s <= '9') -+ s++; -+ if (*s) parity = *s++; -+ if (*s) bits = *s++ - '0'; -+ if (*s) doflow = (*s++ == 'r'); -+ } -+ -+ /* -+ * Now construct a cflag setting. -+ */ -+ switch(baud) { -+ case 1200: -+ cflag |= B1200; -+ break; -+ case 2400: -+ cflag |= B2400; -+ break; -+ case 4800: -+ cflag |= B4800; -+ break; -+ case 19200: -+ cflag |= B19200; -+ break; -+ case 38400: -+ cflag |= B38400; -+ break; -+ case 57600: -+ cflag |= B57600; -+ break; -+ case 115200: -+ cflag |= B115200; -+ break; -+ case 9600: -+ default: -+ cflag |= B9600; -+ /* -+ * Set this to a sane value to prevent a divide error -+ */ -+ baud = 9600; -+ break; -+ } -+ switch(bits) { -+ case 7: -+ cflag |= CS7; -+ break; -+ default: -+ case 8: -+ cflag |= CS8; -+ break; -+ } -+ switch(parity) { -+ case 'o': case 'O': -+ cflag |= PARODD; -+ break; -+ case 'e': case 'E': -+ cflag |= PARENB; -+ break; -+ } -+ co->cflag = cflag; -+ -+ /* -+ * Divisor, bytesize and parity -+ */ -+ state = rs_table + co->index; -+ if (doflow) -+ state->flags |= ASYNC_CONS_FLOW; -+ info = &async_sercons; -+ info->magic = SERIAL_MAGIC; -+ info->state = state; -+ info->port = state->port; -+ info->flags = state->flags; -+#ifdef CONFIG_HUB6 -+ info->hub6 = state->hub6; -+#endif -+ info->io_type = state->io_type; -+ info->iomem_base = state->iomem_base; -+ info->iomem_reg_shift = state->iomem_reg_shift; -+ quot = state->baud_base / baud; -+ cval = cflag & (CSIZE | CSTOPB); -+#if defined(__powerpc__) || defined(__alpha__) -+ cval >>= 8; -+#else /* !__powerpc__ && !__alpha__ */ -+ cval >>= 4; -+#endif /* !__powerpc__ && !__alpha__ */ -+ if (cflag & PARENB) -+ cval |= UART_LCR_PARITY; -+ if (!(cflag & PARODD)) -+ cval |= UART_LCR_EPAR; -+ -+ /* -+ * Disable UART interrupts, set DTR and RTS high -+ * and set speed. -+ */ -+ serial_out(info, UART_LCR, cval | UART_LCR_DLAB); /* set DLAB */ -+ serial_out(info, UART_DLL, quot & 0xff); /* LS of divisor */ -+ serial_out(info, UART_DLM, quot >> 8); /* MS of divisor */ -+ serial_out(info, UART_LCR, cval); /* reset DLAB */ -+ serial_out(info, UART_IER, 0); -+ serial_out(info, UART_MCR, UART_MCR_DTR | UART_MCR_RTS); -+ -+ /* -+ * If we read 0xff from the LSR, there is no UART here. -+ */ -+ if (serial_in(info, UART_LSR) == 0xff) -+ return -1; -+ -+ return 0; -+} -+ -+static struct console sercons = { -+ name: "ttyS", -+ write: serial_console_write, -+ device: serial_console_device, -+ setup: serial_console_setup, -+ flags: CON_PRINTBUFFER, -+ index: -1, -+}; -+ -+/* -+ * Register console. -+ */ -+void __init serial_console_init(void) -+{ -+ register_console(&sercons); -+} -+#endif -+ -+/* -+ Local variables: -+ compile-command: "gcc -D__KERNEL__ -I../../include -Wall -Wstrict-prototypes -O2 -fomit-frame-pointer -fno-strict-aliasing -pipe -fno-strength-reduce -march=i586 -DMODULE -DMODVERSIONS -include ../../include/linux/modversions.h -DEXPORT_SYMTAB -c serial.c" -+ End: -+*/ diff -urN linux.old/drivers/char/ticfg/Makefile linux.dev/drivers/char/ticfg/Makefile --- linux.old/drivers/char/ticfg/Makefile 1970-01-01 01:00:00.000000000 +0100 +++ linux.dev/drivers/char/ticfg/Makefile 2005-11-10 01:10:46.051587500 +0100 |