patch-2.4.22 linux-2.4.22/drivers/char/serial_txx9.c
Next file: linux-2.4.22/drivers/char/sgiserial.c
Previous file: linux-2.4.22/drivers/char/serial_tx3912.c
Back to the patch index
Back to the overall index
- Lines: 1769
- Date:
2003-08-25 04:44:41.000000000 -0700
- Orig file:
linux-2.4.21/drivers/char/serial_txx9.c
- Orig date:
1969-12-31 16:00:00.000000000 -0800
diff -urN linux-2.4.21/drivers/char/serial_txx9.c linux-2.4.22/drivers/char/serial_txx9.c
@@ -0,0 +1,1768 @@
+/*
+ * drivers/char/serial_txx9.c
+ *
+ * Copyright (C) 1999 Harald Koerfgen
+ * Copyright (C) 2000 Jim Pick <jim@jimpick.com>
+ * Copyright (C) 2001 Steven J. Hill (sjhill@realitydiluted.com)
+ * Copyright (C) 2000-2002 Toshiba Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * Serial driver for TX3927/TX4927/TX4925/TX4938 internal SIO controller
+ */
+#include <linux/init.h>
+#include <linux/config.h>
+#include <linux/tty.h>
+#include <linux/major.h>
+#include <linux/ptrace.h>
+#include <linux/init.h>
+#include <linux/console.h>
+#include <linux/fs.h>
+#include <linux/mm.h>
+#include <linux/ioport.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/pm.h>
+#include <asm/io.h>
+#include <asm/uaccess.h>
+#include <asm/delay.h>
+#include <linux/serial.h>
+#include <linux/generic_serial.h>
+#include <linux/pci.h>
+#ifdef CONFIG_MAGIC_SYSRQ
+#include <linux/sysrq.h>
+#endif
+
+#define DEBUG
+#ifdef DEBUG
+#define DBG(x...) printk(x)
+#else
+#define DBG(x...)
+#endif
+
+static char *serial_version = "0.30-mvl";
+static char *serial_name = "TX39/49 Serial driver";
+
+#define GS_INTERNAL_FLAGS (GS_TX_INTEN|GS_RX_INTEN|GS_ACTIVE)
+
+#define TXX9_SERIAL_MAGIC 0x39274927
+
+#ifdef CONFIG_SERIAL
+/* "ttyS","cua" is used for standard serial driver */
+#define TXX9_TTY_NAME "ttyTX"
+#define TXX9_TTY_DEVFS_NAME "tts/TX%d"
+#define TXX9_TTY_MINOR_START (64 + 64) /* ttyTX0(128), ttyTX1(129) */
+#define TXX9_CU_NAME "cuatx"
+#define TXX9_CU_DEVFS_NAME "cua/TX%d"
+#else
+/* acts like standard serial driver */
+#define TXX9_TTY_NAME "ttyS"
+#define TXX9_TTY_DEVFS_NAME "tts/%d"
+#define TXX9_TTY_MINOR_START 64
+#define TXX9_CU_NAME "cua"
+#define TXX9_CU_DEVFS_NAME "cua/%d"
+#endif
+#define TXX9_TTY_MAJOR TTY_MAJOR
+#define TXX9_TTYAUX_MAJOR TTYAUX_MAJOR
+
+#define TXX9_SERIAL_HAVE_CTS_LINE 1
+
+#ifdef CONFIG_PCI
+/* support for Toshiba TC86C001 SIO */
+#define ENABLE_SERIAL_TXX9_PCI
+#endif
+
+/*
+ * Number of serial ports
+ */
+#ifdef ENABLE_SERIAL_TXX9_PCI
+#define NR_PCI_BOARDS 4
+#define NR_PORTS (2 + NR_PCI_BOARDS)
+#else
+#define NR_PORTS 2
+#endif
+
+/*
+ * Hardware specific serial port structure
+ */
+static struct rs_port {
+ struct gs_port gs; /* Must be first field! */
+
+ unsigned long base;
+ int irq;
+ int baud_base;
+ int flags;
+ struct async_icount icount;
+ int x_char; /* XON/XOFF character */
+ int read_status_mask;
+ int ignore_status_mask;
+ int quot;
+ char io_type;
+#ifdef ENABLE_SERIAL_TXX9_PCI
+ struct pci_dev * pci_dev;
+#endif
+} rs_ports[NR_PORTS]
+#ifdef CONFIG_TOSHIBA_RBTX4925
+= {
+ /* NR_PORTS = 0 */
+ {base: 0xff1f0000 + 0xf300,
+ irq: 36,
+ baud_base: 40000000 / 16 / 2,
+ io_type: -1, /* virtual memory mapped */
+ flags: TXX9_SERIAL_HAVE_CTS_LINE,},
+ /* NR_PORTS = 1 */
+ {base: 0xff1f0000 + 0xf400,
+ irq: 37,
+ baud_base: 40000000 / 16 / 2,
+ io_type: -1, /* virtual memory mapped */
+ flags: TXX9_SERIAL_HAVE_CTS_LINE,}
+};
+#endif
+#ifdef CONFIG_TOSHIBA_RBTX4927
+= {
+ /* NR_PORTS = 0 */
+ {base: 0xff1f0000 + 0xf300,
+ irq: 32,
+ baud_base: 50000000 / 16 / 2,
+ io_type: -1, /* virtual memory mapped */
+ flags: TXX9_SERIAL_HAVE_CTS_LINE,},
+ /* NR_PORTS = 1 */
+ {base: 0xff1f0000 + 0xf400,
+ irq: 33,
+ baud_base: 50000000 / 16 / 2,
+ io_type: -1, /* virtual memory mapped */
+ flags: TXX9_SERIAL_HAVE_CTS_LINE,}
+};
+#endif
+
+/* TXX9 Serial Registers */
+#define TXX9_SILCR 0x00
+#define TXX9_SIDICR 0x04
+#define TXX9_SIDISR 0x08
+#define TXX9_SICISR 0x0c
+#define TXX9_SIFCR 0x10
+#define TXX9_SIFLCR 0x14
+#define TXX9_SIBGR 0x18
+#define TXX9_SITFIFO 0x1c
+#define TXX9_SIRFIFO 0x20
+
+/* SILCR : Line Control */
+#define TXX9_SILCR_SCS_MASK 0x00000060
+#define TXX9_SILCR_SCS_IMCLK 0x00000000
+#define TXX9_SILCR_SCS_IMCLK_BG 0x00000020
+#define TXX9_SILCR_SCS_SCLK 0x00000040
+#define TXX9_SILCR_SCS_SCLK_BG 0x00000060
+#define TXX9_SILCR_UEPS 0x00000010
+#define TXX9_SILCR_UPEN 0x00000008
+#define TXX9_SILCR_USBL_MASK 0x00000004
+//#define TXX9_SILCR_USBL_1BIT 0x00000004
+//#define TXX9_SILCR_USBL_2BIT 0x00000000
+#define TXX9_SILCR_USBL_1BIT 0x00000000
+#define TXX9_SILCR_USBL_2BIT 0x00000004
+#define TXX9_SILCR_UMODE_MASK 0x00000003
+#define TXX9_SILCR_UMODE_8BIT 0x00000000
+#define TXX9_SILCR_UMODE_7BIT 0x00000001
+
+/* SIDICR : DMA/Int. Control */
+#define TXX9_SIDICR_TDE 0x00008000
+#define TXX9_SIDICR_RDE 0x00004000
+#define TXX9_SIDICR_TIE 0x00002000
+#define TXX9_SIDICR_RIE 0x00001000
+#define TXX9_SIDICR_SPIE 0x00000800
+#define TXX9_SIDICR_CTSAC 0x00000600
+#define TXX9_SIDICR_STIE_MASK 0x0000003f
+#define TXX9_SIDICR_STIE_OERS 0x00000020
+#define TXX9_SIDICR_STIE_CTSS 0x00000010
+#define TXX9_SIDICR_STIE_RBRKD 0x00000008
+#define TXX9_SIDICR_STIE_TRDY 0x00000004
+#define TXX9_SIDICR_STIE_TXALS 0x00000002
+#define TXX9_SIDICR_STIE_UBRKD 0x00000001
+
+/* SIDISR : DMA/Int. Status */
+#define TXX9_SIDISR_UBRK 0x00008000
+#define TXX9_SIDISR_UVALID 0x00004000
+#define TXX9_SIDISR_UFER 0x00002000
+#define TXX9_SIDISR_UPER 0x00001000
+#define TXX9_SIDISR_UOER 0x00000800
+#define TXX9_SIDISR_ERI 0x00000400
+#define TXX9_SIDISR_TOUT 0x00000200
+#define TXX9_SIDISR_TDIS 0x00000100
+#define TXX9_SIDISR_RDIS 0x00000080
+#define TXX9_SIDISR_STIS 0x00000040
+#define TXX9_SIDISR_RFDN_MASK 0x0000001f
+
+/* SICISR : Change Int. Status */
+#define TXX9_SICISR_OERS 0x00000020
+#define TXX9_SICISR_CTSS 0x00000010
+#define TXX9_SICISR_RBRKD 0x00000008
+#define TXX9_SICISR_TRDY 0x00000004
+#define TXX9_SICISR_TXALS 0x00000002
+#define TXX9_SICISR_UBRKD 0x00000001
+
+/* SIFCR : FIFO Control */
+#define TXX9_SIFCR_SWRST 0x00008000
+#define TXX9_SIFCR_RDIL_MASK 0x00000180
+#define TXX9_SIFCR_RDIL_1 0x00000000
+#define TXX9_SIFCR_RDIL_4 0x00000080
+#define TXX9_SIFCR_RDIL_8 0x00000100
+#define TXX9_SIFCR_RDIL_12 0x00000180
+#define TXX9_SIFCR_RDIL_MAX 0x00000180
+#define TXX9_SIFCR_TDIL_MASK 0x00000018
+#define TXX9_SIFCR_TDIL_MASK 0x00000018
+#define TXX9_SIFCR_TDIL_1 0x00000000
+#define TXX9_SIFCR_TDIL_4 0x00000001
+#define TXX9_SIFCR_TDIL_8 0x00000010
+#define TXX9_SIFCR_TDIL_MAX 0x00000010
+#define TXX9_SIFCR_TFRST 0x00000004
+#define TXX9_SIFCR_RFRST 0x00000002
+#define TXX9_SIFCR_FRSTE 0x00000001
+#define TXX9_SIO_TX_FIFO 8
+#define TXX9_SIO_RX_FIFO 16
+
+/* SIFLCR : Flow Control */
+#define TXX9_SIFLCR_RCS 0x00001000
+#define TXX9_SIFLCR_TES 0x00000800
+#define TXX9_SIFLCR_RTSSC 0x00000200
+#define TXX9_SIFLCR_RSDE 0x00000100
+#define TXX9_SIFLCR_TSDE 0x00000080
+#define TXX9_SIFLCR_RTSTL_MASK 0x0000001e
+#define TXX9_SIFLCR_RTSTL_MAX 0x0000001e
+#define TXX9_SIFLCR_TBRK 0x00000001
+
+/* SIBGR : Baudrate Control */
+#define TXX9_SIBGR_BCLK_MASK 0x00000300
+#define TXX9_SIBGR_BCLK_T0 0x00000000
+#define TXX9_SIBGR_BCLK_T2 0x00000100
+#define TXX9_SIBGR_BCLK_T4 0x00000200
+#define TXX9_SIBGR_BCLK_T6 0x00000300
+#define TXX9_SIBGR_BRD_MASK 0x000000ff
+
+static /*inline*/ unsigned int
+sio_in(struct rs_port *port, int offset)
+{
+ if (port->io_type < 0)
+ /* don't use __raw_readl that does swapping for big endian */
+ return (*(volatile unsigned long*)(port->base + offset));
+ else
+ return inl(port->base + offset);
+}
+
+static /*inline*/ void
+sio_out(struct rs_port *port, int offset, unsigned int value)
+{
+ if (port->io_type < 0)
+ /* don't use __raw_writel that does swapping for big endian */
+ (*(volatile unsigned long*)(port->base + offset))=(value);
+ else
+ outl(value, port->base + offset);
+}
+
+static inline void
+sio_mask(struct rs_port *port, int offset, unsigned int value)
+{
+ sio_out(port, offset, sio_in(port, offset) & ~value);
+}
+static inline void
+sio_set(struct rs_port *port, int offset, unsigned int value)
+{
+ sio_out(port, offset, sio_in(port, offset) | value);
+}
+
+/*
+ * Forward declarations for serial routines
+ */
+static void rs_disable_tx_interrupts (void * ptr);
+static void rs_enable_tx_interrupts (void * ptr);
+static void rs_disable_rx_interrupts (void * ptr);
+static void rs_enable_rx_interrupts (void * ptr);
+static int rs_get_CD (void * ptr);
+static void rs_shutdown_port (void * ptr);
+static int rs_set_real_termios (void *ptr);
+static int rs_chars_in_buffer (void * ptr);
+static void rs_hungup (void *ptr);
+static void rs_getserial (void*, struct serial_struct *sp);
+static void rs_close (void *ptr);
+
+/*
+ * Used by generic serial driver to access hardware
+ */
+static struct real_driver rs_real_driver = {
+ disable_tx_interrupts: rs_disable_tx_interrupts,
+ enable_tx_interrupts: rs_enable_tx_interrupts,
+ disable_rx_interrupts: rs_disable_rx_interrupts,
+ enable_rx_interrupts: rs_enable_rx_interrupts,
+ get_CD: rs_get_CD,
+ shutdown_port: rs_shutdown_port,
+ set_real_termios: rs_set_real_termios,
+ chars_in_buffer: rs_chars_in_buffer,
+ close: rs_close,
+ hungup: rs_hungup,
+ getserial: rs_getserial,
+};
+
+/*
+ * Structures and such for TTY sessions and usage counts
+ */
+static struct tty_driver rs_driver, rs_callout_driver;
+static struct tty_struct *rs_table[NR_PORTS];
+static struct termios *rs_termios[NR_PORTS];
+static struct termios *rs_termios_locked[NR_PORTS];
+int rs_refcount;
+int rs_initialized = 0;
+
+#ifdef CONFIG_SERIAL_TXX9_CONSOLE
+static struct console sercons;
+#endif
+#if defined(CONFIG_SERIAL_TXX9_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
+static unsigned long break_pressed; /* break, really ... */
+#endif
+
+static inline void receive_chars(struct rs_port *port,
+ int *status, struct pt_regs *regs)
+{
+ struct tty_struct *tty = port->gs.tty;
+ unsigned char ch;
+ struct async_icount *icount;
+ int max_count = 256;
+
+ icount = &port->icount;
+ do {
+ if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
+ tty->flip.tqueue.routine((void *) tty);
+ if (tty->flip.count >= TTY_FLIPBUF_SIZE)
+ return; // if TTY_DONT_FLIP is set
+ }
+ ch = sio_in(port, TXX9_SIRFIFO);
+ *tty->flip.char_buf_ptr = ch;
+ icount->rx++;
+
+ *tty->flip.flag_buf_ptr = 0;
+ if (*status & (TXX9_SIDISR_UBRK | TXX9_SIDISR_UPER |
+ TXX9_SIDISR_UFER | TXX9_SIDISR_UOER)) {
+ /*
+ * For statistics only
+ */
+ if (*status & TXX9_SIDISR_UBRK) {
+ *status &= ~(TXX9_SIDISR_UFER | TXX9_SIDISR_UPER);
+ 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_TXX9_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
+ if (port == &rs_ports[sercons.index]) {
+ if (!break_pressed) {
+ break_pressed = jiffies;
+ goto ignore_char;
+ }
+ break_pressed = 0;
+ }
+#endif
+ if (port->gs.flags & ASYNC_SAK)
+ do_SAK(tty);
+ } else if (*status & TXX9_SIDISR_UPER)
+ icount->parity++;
+ else if (*status & TXX9_SIDISR_UFER)
+ icount->frame++;
+ if (*status & TXX9_SIDISR_UOER)
+ icount->overrun++;
+
+ /*
+ * Mask off conditions which should be ignored.
+ */
+ *status &= port->read_status_mask;
+
+#ifdef CONFIG_SERIAL_TXX9_CONSOLE
+ /* Break flag is updated by reading RFIFO. */
+#endif
+ if (*status & (TXX9_SIDISR_UBRK)) {
+ *tty->flip.flag_buf_ptr = TTY_BREAK;
+ } else if (*status & TXX9_SIDISR_UPER)
+ *tty->flip.flag_buf_ptr = TTY_PARITY;
+ else if (*status & TXX9_SIDISR_UFER)
+ *tty->flip.flag_buf_ptr = TTY_FRAME;
+ }
+#if defined(CONFIG_SERIAL_TXX9_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
+ if (break_pressed && port == &rs_ports[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 & port->ignore_status_mask) == 0) {
+ tty->flip.flag_buf_ptr++;
+ tty->flip.char_buf_ptr++;
+ tty->flip.count++;
+ }
+ if ((*status & TXX9_SIDISR_UOER) &&
+ (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_TXX9_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
+ ignore_char:
+#endif
+ *status = sio_in(port, TXX9_SIDISR);
+ } while ((!(*status & TXX9_SIDISR_UVALID)) && (max_count-- > 0));
+ tty_flip_buffer_push(tty);
+}
+
+static inline void transmit_chars(struct rs_port *port)
+{
+ int count;
+
+ if (port->x_char) {
+ sio_out(port, TXX9_SITFIFO, port->x_char);
+ port->icount.tx++;
+ port->x_char = 0;
+ return;
+ }
+ if (port->gs.xmit_cnt <= 0
+ || port->gs.tty->stopped
+ || port->gs.tty->hw_stopped) {
+ rs_disable_tx_interrupts(port);
+ return;
+ }
+
+ count = TXX9_SIO_TX_FIFO;
+ do {
+ sio_out(port, TXX9_SITFIFO, port->gs.xmit_buf[port->gs.xmit_tail++]);
+ port->gs.xmit_tail &= SERIAL_XMIT_SIZE-1;
+ port->icount.tx++;
+ if (--port->gs.xmit_cnt <= 0)
+ break;
+ } while (--count > 0);
+
+ if (port->gs.xmit_cnt <= 0 || port->gs.tty->stopped ||
+ port->gs.tty->hw_stopped) {
+ rs_disable_tx_interrupts(port);
+ }
+
+ if (port->gs.xmit_cnt <= port->gs.wakeup_chars) {
+ if ((port->gs.tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) &&
+ port->gs.tty->ldisc.write_wakeup)
+ (port->gs.tty->ldisc.write_wakeup)(port->gs.tty);
+ wake_up_interruptible(&port->gs.tty->write_wait);
+ }
+}
+
+static inline void check_modem_status(struct rs_port *port)
+{
+ /* We don't have a carrier detect line - but just respond
+ like we had one anyways so that open() becomes unblocked */
+ wake_up_interruptible(&port->gs.open_wait);
+}
+
+#define RS_ISR_PASS_LIMIT 256
+
+static void rs_interrupt(int irq, void *dev_id, struct pt_regs * regs)
+{
+ struct rs_port * port = (struct rs_port *)dev_id;
+ unsigned long flags;
+ int status;
+ int pass_counter = 0;
+
+ local_irq_save(flags);
+
+ if (!port || !port->gs.tty) {
+ local_irq_restore(flags);
+ return;
+ }
+
+ do {
+ status = sio_in(port, TXX9_SIDISR);
+ if (!(sio_in(port, TXX9_SIDICR) & TXX9_SIDICR_TIE))
+ status &= ~TXX9_SIDISR_TDIS;
+ if (!(status & (TXX9_SIDISR_TDIS | TXX9_SIDISR_RDIS |
+ TXX9_SIDISR_TOUT)))
+ break;
+
+ if (status & TXX9_SIDISR_RDIS)
+ receive_chars(port, &status, regs);
+#if 0 /* RTS/CTS are controled by HW. (if possible) */
+ check_modem_status(port);
+#endif
+ if (status & TXX9_SIDISR_TDIS)
+ transmit_chars(port);
+ /* Clear TX/RX Int. Status */
+ sio_mask(port, TXX9_SIDISR,
+ TXX9_SIDISR_TDIS | TXX9_SIDISR_RDIS |
+ TXX9_SIDISR_TOUT);
+
+ if (pass_counter++ > RS_ISR_PASS_LIMIT) {
+ break;
+ }
+ } while (1);
+ local_irq_restore(flags);
+}
+
+/*
+ ***********************************************************************
+ * Here are the routines that actually *
+ * interface with the generic_serial driver *
+ ***********************************************************************
+ */
+static void rs_disable_tx_interrupts (void * ptr)
+{
+ struct rs_port *port = ptr;
+ unsigned long flags;
+
+ local_irq_save(flags);
+ port->gs.flags &= ~GS_TX_INTEN;
+ sio_mask(port, TXX9_SIDICR, TXX9_SIDICR_TIE);
+ local_irq_restore(flags);
+}
+
+static void rs_enable_tx_interrupts (void * ptr)
+{
+ struct rs_port *port = ptr;
+ unsigned long flags;
+
+ local_irq_save(flags);
+ sio_set(port, TXX9_SIDICR, TXX9_SIDICR_TIE);
+ local_irq_restore(flags);
+}
+
+static void rs_disable_rx_interrupts (void * ptr)
+{
+ struct rs_port *port = ptr;
+ unsigned long flags;
+
+ local_irq_save(flags);
+ port->read_status_mask &= ~TXX9_SIDISR_RDIS;
+#if 0
+ sio_mask(port, TXX9_SIDICR, TXX9_SIDICR_RIE);
+#endif
+ local_irq_restore(flags);
+}
+
+static void rs_enable_rx_interrupts (void * ptr)
+{
+ struct rs_port *port = ptr;
+ sio_set(port, TXX9_SIDICR, TXX9_SIDICR_RIE);
+}
+
+
+static int rs_get_CD (void * ptr)
+{
+ /* No Carried Detect in Hardware - just return true */
+ return (1);
+}
+
+static void rs_shutdown_port (void * ptr)
+{
+ struct rs_port *port = ptr;
+
+ port->gs.flags &= ~GS_ACTIVE;
+
+ free_irq(port->irq, port);
+ sio_out(port, TXX9_SIDICR, 0); /* disable all intrs */
+ /* disable break condition */
+ sio_mask(port, TXX9_SIFLCR, TXX9_SIFLCR_TBRK);
+
+#ifdef CONFIG_SERIAL_TXX9_CONSOLE
+ if (port == &rs_ports[sercons.index]) {
+#endif
+ if (!port->gs.tty || (port->gs.tty->termios->c_cflag & HUPCL)) {
+ /* drop RTS */
+ sio_set(port, TXX9_SIFLCR,
+ TXX9_SIFLCR_RTSSC | TXX9_SIFLCR_RSDE);
+ /* TXX9-SIO can not control DTR... */
+ }
+
+ /* reset FIFO's */
+ sio_set(port, TXX9_SIFCR,
+ TXX9_SIFCR_TFRST | TXX9_SIFCR_RFRST | TXX9_SIFCR_FRSTE);
+ /* clear reset */
+ sio_mask(port, TXX9_SIFCR,
+ TXX9_SIFCR_TFRST | TXX9_SIFCR_RFRST | TXX9_SIFCR_FRSTE);
+ /* Disable RX/TX */
+ sio_set(port, TXX9_SIFLCR, TXX9_SIFLCR_RSDE | TXX9_SIFLCR_TSDE);
+#ifdef CONFIG_SERIAL_TXX9_CONSOLE
+ }
+#endif
+}
+
+static int rs_set_real_termios (void *ptr)
+{
+ struct rs_port *port = ptr;
+ int quot = 0, baud_base, baud;
+ unsigned cflag, cval, fcr = 0;
+ int bits;
+ unsigned long flags;
+
+ if (!port->gs.tty || !port->gs.tty->termios)
+ return 0;
+ cflag = port->gs.tty->termios->c_cflag;
+ cval = sio_in(port, TXX9_SILCR);
+ /* byte size and parity */
+ cval &= ~TXX9_SILCR_UMODE_MASK;
+ switch (cflag & CSIZE) {
+ case CS7:
+ cval |= TXX9_SILCR_UMODE_7BIT;
+ bits = 9;
+ break;
+ case CS5: /* not supported */
+ case CS6: /* not supported */
+ case CS8:
+ default:
+ cval |= TXX9_SILCR_UMODE_8BIT;
+ bits = 10;
+ break;
+ }
+ cval &= ~TXX9_SILCR_USBL_MASK;
+ if (cflag & CSTOPB) {
+ cval |= TXX9_SILCR_USBL_2BIT;
+ bits++;
+ } else {
+ cval |= TXX9_SILCR_USBL_1BIT;
+ }
+
+ cval &= ~(TXX9_SILCR_UPEN | TXX9_SILCR_UEPS);
+ if (cflag & PARENB) {
+ cval |= TXX9_SILCR_UPEN;
+ bits++;
+ }
+ if (!(cflag & PARODD))
+ cval |= TXX9_SILCR_UEPS;
+
+ /* Determine divisor based on baud rate */
+ baud = tty_get_baud_rate(port->gs.tty);
+ if (!baud)
+ baud = 9600; /* B0 transition handled in rs_set_termios */
+ baud_base = port->baud_base;
+ quot = (baud_base + baud / 2) / baud;
+ /* As a last resort, if the quotient is zero, default to 9600 bps */
+ if (!quot)
+ quot = (baud_base + 9600 / 2) / 9600;
+ port->quot = quot;
+
+ /* Set up FIFO's */
+ /* TX Int by FIFO Empty, RX Int by Receiving 1 char. */
+ fcr = TXX9_SIFCR_TDIL_MAX | TXX9_SIFCR_RDIL_1;
+
+ /* CTS flow control flag */
+ if (cflag & CRTSCTS) {
+ port->gs.flags |= ASYNC_CTS_FLOW;
+ if (port->flags & TXX9_SERIAL_HAVE_CTS_LINE)
+ sio_out(port, TXX9_SIFLCR,
+ TXX9_SIFLCR_RCS | TXX9_SIFLCR_TES |
+ TXX9_SIFLCR_RTSTL_MAX /* 15 */);
+ } else {
+ port->gs.flags &= ~ASYNC_CTS_FLOW;
+ sio_mask(port, TXX9_SIFLCR,
+ TXX9_SIFLCR_RCS | TXX9_SIFLCR_TES |
+ TXX9_SIFLCR_RSDE | TXX9_SIFLCR_TSDE);
+ }
+
+ /*
+ * Set up parity check flag
+ */
+#define RELEVANT_IFLAG(iflag) (iflag & (IGNBRK|BRKINT|IGNPAR|PARMRK|INPCK))
+
+ port->read_status_mask = TXX9_SIDISR_UOER |
+ TXX9_SIDISR_TDIS | TXX9_SIDISR_RDIS;
+ if (I_INPCK(port->gs.tty))
+ port->read_status_mask |= TXX9_SIDISR_UFER | TXX9_SIDISR_UPER;
+ if (I_BRKINT(port->gs.tty) || I_PARMRK(port->gs.tty))
+ port->read_status_mask |= TXX9_SIDISR_UBRK;
+
+ /*
+ * Characters to ignore
+ */
+ port->ignore_status_mask = 0;
+ if (I_IGNPAR(port->gs.tty))
+ port->ignore_status_mask |= TXX9_SIDISR_UPER | TXX9_SIDISR_UFER;
+ if (I_IGNBRK(port->gs.tty)) {
+ port->ignore_status_mask |= TXX9_SIDISR_UBRK;
+ /*
+ * If we're ignore parity and break indicators, ignore
+ * overruns too. (For real raw support).
+ */
+ if (I_IGNPAR(port->gs.tty))
+ port->ignore_status_mask |= TXX9_SIDISR_UOER;
+ }
+#if 0 /* XXX: This cause problem with some programs(init, mingetty, etc) */
+ /*
+ * !!! ignore all characters if CREAD is not set
+ */
+ if ((cflag & CREAD) == 0)
+ port->ignore_status_mask |= TXX9_SIDISR_RDIS;
+#endif
+ local_irq_save(flags);
+ cval &= ~TXX9_SILCR_SCS_IMCLK;
+ sio_out(port, TXX9_SILCR, cval | TXX9_SILCR_SCS_IMCLK_BG);
+ sio_out(port, TXX9_SIBGR, quot | TXX9_SIBGR_BCLK_T0);
+ sio_out(port, TXX9_SIFCR, fcr);
+ local_irq_restore(flags);
+ return 0;
+}
+
+static int rs_chars_in_buffer (void * ptr)
+{
+ struct rs_port *port = ptr;
+
+ /* return 0 if transmitter disabled. */
+ if (sio_in(port, TXX9_SIFLCR) & TXX9_SIFLCR_TSDE)
+ return 0;
+ return (sio_in(port, TXX9_SICISR) & TXX9_SICISR_TXALS) ? 0 : 1;
+}
+
+/* ********************************************************************** *
+ * Here are the routines that actually *
+ * interface with the rest of the system *
+ * ********************************************************************** */
+static int rs_open (struct tty_struct * tty, struct file * filp)
+{
+ struct rs_port *port;
+ int retval, line;
+
+ if (!rs_initialized) {
+ return -EIO;
+ }
+
+ line = MINOR(tty->device) - tty->driver.minor_start;
+
+ if ((line < 0) || (line >= NR_PORTS))
+ return -ENODEV;
+
+ /* Pre-initialized already */
+ port = & rs_ports[line];
+
+ if (!port->base)
+ return -ENODEV;
+
+ tty->driver_data = port;
+ port->gs.tty = tty;
+ port->gs.count++;
+
+ /*
+ * Start up serial port
+ */
+ retval = gs_init_port(&port->gs);
+ if (retval) {
+ port->gs.count--;
+ return retval;
+ }
+
+ port->gs.flags |= GS_ACTIVE;
+
+ if (port->gs.count == 1) {
+ MOD_INC_USE_COUNT;
+
+ /*
+ * Clear the FIFO buffers and disable them
+ * (they will be reenabled in rs_set_real_termios())
+ */
+ sio_set(port, TXX9_SIFCR,
+ TXX9_SIFCR_TFRST | TXX9_SIFCR_RFRST |
+ TXX9_SIFCR_FRSTE);
+ /* clear reset */
+ sio_mask(port, TXX9_SIFCR,
+ TXX9_SIFCR_TFRST | TXX9_SIFCR_RFRST |
+ TXX9_SIFCR_FRSTE);
+ sio_out(port, TXX9_SIDICR, 0);
+
+ retval = request_irq(port->irq, rs_interrupt, SA_SHIRQ,
+ "serial_txx9", port);
+ if (retval) {
+ printk(KERN_ERR "serial_txx9: request_irq: err %d\n",
+ retval);
+ MOD_DEC_USE_COUNT;
+ port->gs.count--;
+ return retval;
+ }
+ /*
+ * Clear the interrupt registers.
+ */
+ sio_out(port, TXX9_SIDISR, 0);
+
+ /* HW RTS/CTS control */
+ if (port->flags & TXX9_SERIAL_HAVE_CTS_LINE)
+ sio_out(port, TXX9_SIFLCR,
+ TXX9_SIFLCR_RCS | TXX9_SIFLCR_TES |
+ TXX9_SIFLCR_RTSTL_MAX /* 15 */);
+ }
+
+ /* Enable RX/TX */
+ sio_mask(port, TXX9_SIFLCR, TXX9_SIFLCR_RSDE | TXX9_SIFLCR_TSDE);
+
+ /*
+ * Finally, enable interrupts
+ */
+ rs_enable_rx_interrupts(port);
+
+ /*
+ * and set the speed of the serial port
+ */
+ rs_set_real_termios(port);
+
+ retval = gs_block_til_ready(&port->gs, filp);
+
+ if (retval) {
+ if (port->gs.count == 1) {
+ free_irq(port->irq, port);
+ MOD_DEC_USE_COUNT;
+ }
+ port->gs.count--;
+ return retval;
+ }
+ /* tty->low_latency = 1; */
+
+ if ((port->gs.count == 1) && (port->gs.flags & ASYNC_SPLIT_TERMIOS)) {
+ if (tty->driver.subtype == SERIAL_TYPE_NORMAL)
+ *tty->termios = port->gs.normal_termios;
+ else
+ *tty->termios = port->gs.callout_termios;
+ rs_set_real_termios(port);
+ }
+#ifdef CONFIG_SERIAL_TXX9_CONSOLE
+ if (sercons.cflag && sercons.index == line) {
+ tty->termios->c_cflag = sercons.cflag;
+ sercons.cflag = 0;
+ rs_set_real_termios(port);
+ }
+#endif
+ port->gs.session = current->session;
+ port->gs.pgrp = current->pgrp;
+ return 0;
+}
+
+/*
+ * /proc fs routines....
+ */
+
+static inline int line_info(char *buf, struct rs_port *port)
+{
+ char stat_buf[30];
+ int ret;
+ unsigned long flags;
+
+ ret = sprintf(buf, "%d: uart:txx9 io%s:%lx irq:%d",
+ port - &rs_ports[0],
+ port->io_type < 0 ? "mem" : "port",
+ port->base, port->irq);
+
+ if (!port->base) {
+ ret += sprintf(buf+ret, "\n");
+ return ret;
+ }
+
+ /*
+ * Figure out the current RS-232 lines
+ */
+ stat_buf[0] = 0;
+ stat_buf[1] = 0;
+ local_irq_save(flags);
+ if (!(sio_in(port, TXX9_SIFLCR) & TXX9_SIFLCR_RTSSC))
+ strcat(stat_buf, "|RTS");
+ if (!(sio_in(port, TXX9_SICISR) & TXX9_SICISR_CTSS))
+ strcat(stat_buf, "|CTS");
+ local_irq_restore(flags);
+
+ if (port->quot) {
+ ret += sprintf(buf+ret, " baud:%d",
+ port->baud_base / port->quot);
+ }
+
+ ret += sprintf(buf+ret, " tx:%d rx:%d",
+ port->icount.tx, port->icount.rx);
+
+ if (port->icount.frame)
+ ret += sprintf(buf+ret, " fe:%d", port->icount.frame);
+
+ if (port->icount.parity)
+ ret += sprintf(buf+ret, " pe:%d", port->icount.parity);
+
+ if (port->icount.brk)
+ ret += sprintf(buf+ret, " brk:%d", port->icount.brk);
+
+ if (port->icount.overrun)
+ ret += sprintf(buf+ret, " oe:%d", port->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\n", serial_version);
+ for (i = 0; i < NR_PORTS && len < 4000; i++) {
+ l = line_info(page + len, &rs_ports[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 + (begin-off);
+ return ((count < begin+len-off) ? count : begin+len-off);
+}
+
+static void rs_close (void *ptr)
+{
+#if 0
+ struct rs_port *port = ptr;
+ free_irq(port->irq, port);
+#endif
+ MOD_DEC_USE_COUNT;
+}
+
+/* I haven't the foggiest why the decrement use count has to happen
+ here. The whole linux serial drivers stuff needs to be redesigned.
+ My guess is that this is a hack to minimize the impact of a bug
+ elsewhere. Thinking about it some more. (try it sometime) Try
+ running minicom on a serial port that is driven by a modularized
+ driver. Have the modem hangup. Then remove the driver module. Then
+ exit minicom. I expect an "oops". -- REW */
+static void rs_hungup (void *ptr)
+{
+ MOD_DEC_USE_COUNT;
+}
+
+static void rs_getserial (void *ptr, struct serial_struct *sp)
+{
+ struct rs_port *port = ptr;
+ struct tty_struct *tty = port->gs.tty;
+ /* some applications (busybox, dbootstrap, etc.) look this */
+ sp->line = MINOR(tty->device) - tty->driver.minor_start;
+}
+
+/*
+ * rs_break() --- routine which turns the break handling on or off
+ */
+static void rs_break(struct tty_struct *tty, int break_state)
+{
+ struct rs_port *port = tty->driver_data;
+ unsigned long flags;
+
+ if (!port->base)
+ return;
+ local_irq_save(flags);
+ if (break_state == -1)
+ sio_set(port, TXX9_SIFLCR, TXX9_SIFLCR_TBRK);
+ else
+ sio_mask(port, TXX9_SIFLCR, TXX9_SIFLCR_TBRK);
+ local_irq_restore(flags);
+}
+
+static int get_modem_info(struct rs_port *port, unsigned int *value)
+{
+ unsigned int result;
+ unsigned long flags;
+
+ local_irq_save(flags);
+ result = ((sio_in(port, TXX9_SIFLCR) & TXX9_SIFLCR_RTSSC) ? 0 : TIOCM_RTS)
+ | ((sio_in(port, TXX9_SICISR) & TXX9_SICISR_CTSS) ? 0 : TIOCM_CTS);
+ local_irq_restore(flags);
+ return put_user(result,value);
+}
+
+static int set_modem_info(struct rs_port *port, unsigned int cmd,
+ unsigned int *value)
+{
+ int error = 0;
+ unsigned int arg;
+ unsigned long flags;
+
+ if (copy_from_user(&arg, value, sizeof(int)))
+ return -EFAULT;
+
+ local_irq_save(flags);
+ switch (cmd) {
+ case TIOCMBIS:
+ if (arg & TIOCM_RTS)
+ sio_mask(port, TXX9_SIFLCR,
+ TXX9_SIFLCR_RTSSC | TXX9_SIFLCR_RSDE);
+ break;
+ case TIOCMBIC:
+ if (arg & TIOCM_RTS)
+ sio_set(port, TXX9_SIFLCR,
+ TXX9_SIFLCR_RTSSC | TXX9_SIFLCR_RSDE);
+ break;
+ case TIOCMSET:
+ if (arg & TIOCM_RTS)
+ sio_mask(port, TXX9_SIFLCR,
+ TXX9_SIFLCR_RTSSC | TXX9_SIFLCR_RSDE);
+ else
+ sio_set(port, TXX9_SIFLCR,
+ TXX9_SIFLCR_RTSSC | TXX9_SIFLCR_RSDE);
+ break;
+ default:
+ error = -EINVAL;
+ }
+ local_irq_restore(flags);
+ return error;
+}
+
+static int rs_ioctl (struct tty_struct * tty, struct file * filp,
+ unsigned int cmd, unsigned long arg)
+{
+ int rc;
+ struct rs_port *port = tty->driver_data;
+ int ival;
+
+ rc = 0;
+ switch (cmd) {
+ case TIOCMGET:
+ return get_modem_info(port, (unsigned int *) arg);
+ case TIOCMBIS:
+ case TIOCMBIC:
+ case TIOCMSET:
+ return set_modem_info(port, cmd, (unsigned int *) arg);
+ return 0;
+ case TIOCGSOFTCAR:
+ rc = put_user(((tty->termios->c_cflag & CLOCAL) ? 1 : 0),
+ (unsigned int *) arg);
+ break;
+ case TIOCSSOFTCAR:
+ if ((rc = verify_area(VERIFY_READ, (void *) arg,
+ sizeof(int))) == 0) {
+ get_user(ival, (unsigned int *) arg);
+ tty->termios->c_cflag =
+ (tty->termios->c_cflag & ~CLOCAL) |
+ (ival ? CLOCAL : 0);
+ }
+ break;
+ case TIOCGSERIAL:
+ if ((rc = verify_area(VERIFY_WRITE, (void *) arg,
+ sizeof(struct serial_struct))) == 0)
+ rc = gs_getserial(&port->gs, (struct serial_struct *) arg);
+ break;
+ case TIOCSSERIAL:
+ if ((rc = verify_area(VERIFY_READ, (void *) arg,
+ sizeof(struct serial_struct))) == 0)
+ rc = gs_setserial(&port->gs, (struct serial_struct *) arg);
+ break;
+ default:
+ rc = -ENOIOCTLCMD;
+ break;
+ }
+
+ return rc;
+}
+
+
+/*
+ * 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 rs_port *port = (struct rs_port *)tty->driver_data;
+
+ port->x_char = ch;
+ if (ch) {
+ /* Make sure transmit interrupts are on */
+ rs_enable_tx_interrupts(tty);
+ }
+}
+
+
+/*
+ * ------------------------------------------------------------
+ * 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 rs_port *port = (struct rs_port *)tty->driver_data;
+ unsigned long flags;
+
+ if (I_IXOFF(tty))
+ rs_send_xchar(tty, STOP_CHAR(tty));
+ if (tty->termios->c_cflag & CRTSCTS) {
+ local_irq_save(flags);
+ /* drop RTS */
+ sio_set(port, TXX9_SIFLCR,
+ TXX9_SIFLCR_RTSSC | TXX9_SIFLCR_RSDE);
+ local_irq_restore(flags);
+ }
+}
+
+static void rs_unthrottle(struct tty_struct * tty)
+{
+ struct rs_port *port = tty->driver_data;
+ unsigned long flags;
+
+ if (I_IXOFF(tty)) {
+ if (port->x_char)
+ port->x_char = 0;
+ else
+ rs_send_xchar(tty, START_CHAR(tty));
+ }
+ if (tty->termios->c_cflag & CRTSCTS) {
+ local_irq_save(flags);
+ sio_mask(port, TXX9_SIFLCR,
+ TXX9_SIFLCR_RTSSC | TXX9_SIFLCR_RSDE);
+ local_irq_restore(flags);
+ }
+}
+
+/* ********************************************************************** *
+ * Here are the initialization routines. *
+ * ********************************************************************** */
+
+static inline void show_serial_version(void)
+{
+ printk(KERN_INFO "%s version %s\n", serial_name, serial_version);
+}
+
+static int rs_init_portstructs(void)
+{
+ struct rs_port *port;
+ int i;
+
+ /* Adjust the values in the "driver" */
+ rs_driver.termios = rs_termios;
+ rs_driver.termios_locked = rs_termios_locked;
+
+ port = rs_ports;
+ for (i=0; i < NR_PORTS;i++) {
+ port->gs.callout_termios = tty_std_termios;
+ port->gs.normal_termios = tty_std_termios;
+ port->gs.magic = TXX9_SERIAL_MAGIC;
+ port->gs.close_delay = HZ/2;
+ port->gs.closing_wait = 30 * HZ;
+ port->gs.rd = &rs_real_driver;
+#ifdef NEW_WRITE_LOCKING
+ port->gs.port_write_sem = MUTEX;
+#endif
+#ifdef DECLARE_WAITQUEUE
+ init_waitqueue_head(&port->gs.open_wait);
+ init_waitqueue_head(&port->gs.close_wait);
+#endif
+ port++;
+ }
+
+ return 0;
+}
+
+static int rs_init_drivers(void)
+{
+ int error;
+
+ memset(&rs_driver, 0, sizeof(rs_driver));
+ rs_driver.magic = TTY_DRIVER_MAGIC;
+ rs_driver.driver_name = "serial_txx9";
+#if defined(CONFIG_DEVFS_FS)
+ rs_driver.name = TXX9_TTY_DEVFS_NAME;
+#else
+ rs_driver.name = TXX9_TTY_NAME;
+#endif
+ rs_driver.major = TXX9_TTY_MAJOR;
+ rs_driver.minor_start = TXX9_TTY_MINOR_START;
+ rs_driver.num = NR_PORTS;
+ rs_driver.type = TTY_DRIVER_TYPE_SERIAL;
+ rs_driver.subtype = SERIAL_TYPE_NORMAL;
+ rs_driver.init_termios = tty_std_termios;
+ rs_driver.init_termios.c_cflag =
+ B9600 | CS8 | CREAD | HUPCL | CLOCAL;
+ rs_driver.refcount = &rs_refcount;
+ rs_driver.table = rs_table;
+ rs_driver.termios = rs_termios;
+ rs_driver.termios_locked = rs_termios_locked;
+
+ rs_driver.open = rs_open;
+ rs_driver.close = gs_close;
+ rs_driver.write = gs_write;
+ rs_driver.put_char = gs_put_char;
+ rs_driver.flush_chars = gs_flush_chars;
+ rs_driver.write_room = gs_write_room;
+ rs_driver.chars_in_buffer = gs_chars_in_buffer;
+ rs_driver.flush_buffer = gs_flush_buffer;
+ rs_driver.ioctl = rs_ioctl;
+ rs_driver.throttle = rs_throttle;
+ rs_driver.unthrottle = rs_unthrottle;
+ rs_driver.set_termios = gs_set_termios;
+ rs_driver.stop = gs_stop;
+ rs_driver.start = gs_start;
+ rs_driver.hangup = gs_hangup;
+ rs_driver.break_ctl = rs_break;
+ rs_driver.read_proc = rs_read_proc;
+
+ rs_callout_driver = rs_driver;
+#if defined(CONFIG_DEVFS_FS)
+ rs_callout_driver.name = TXX9_CU_DEVFS_NAME;
+#else
+ rs_callout_driver.name = TXX9_CU_NAME;
+#endif
+ rs_callout_driver.major = TXX9_TTYAUX_MAJOR;
+ rs_callout_driver.subtype = SERIAL_TYPE_CALLOUT;
+ rs_callout_driver.read_proc = 0;
+ rs_callout_driver.proc_entry = 0;
+
+ if ((error = tty_register_driver(&rs_driver))) {
+ printk(KERN_ERR
+ "Couldn't register serial driver, error = %d\n",
+ error);
+ return 1;
+ }
+ if ((error = tty_register_driver(&rs_callout_driver))) {
+ tty_unregister_driver(&rs_driver);
+ printk(KERN_ERR
+ "Couldn't register callout driver, error = %d\n",
+ error);
+ return 1;
+ }
+
+ return 0;
+}
+
+/*
+ * This routine is called by txx9_rs_init() to initialize a specific serial
+ * port.
+ */
+static void txx9_config(struct rs_port *port)
+{
+ unsigned long flags;
+
+ if (port - &rs_ports[0] != sercons.index) {
+ local_irq_save(flags);
+ /*
+ * Reset the UART.
+ */
+ sio_out(port, TXX9_SIFCR, TXX9_SIFCR_SWRST);
+#ifdef CONFIG_CPU_TX49XX
+ /* TX4925 BUG WORKAROUND. Accessing SIOC register
+ * immediately after soft reset causes bus error. */
+ wbflush();/* change iob(); */
+ udelay(1);
+#endif
+ while (sio_in(port, TXX9_SIFCR) & TXX9_SIFCR_SWRST)
+ ;
+ /* TX Int by FIFO Empty, RX Int by Receiving 1 char. */
+ sio_set(port, TXX9_SIFCR,
+ TXX9_SIFCR_TDIL_MAX | TXX9_SIFCR_RDIL_1);
+ /* initial settings */
+ sio_out(port, TXX9_SILCR,
+ TXX9_SILCR_UMODE_8BIT | TXX9_SILCR_USBL_1BIT |
+ TXX9_SILCR_SCS_IMCLK_BG);
+ sio_out(port, TXX9_SIBGR,
+ ((port->baud_base + 9600 / 2) / 9600) |
+ TXX9_SIBGR_BCLK_T0);
+ local_irq_restore(flags);
+ }
+ DBG("txx9_config: port->io_type is %d\n", port->io_type);
+ if (port->io_type < 0)
+ request_mem_region(port->base, 36, "serial_txx9");
+ else
+ request_region(port->base, 36, "serial_txx9");
+}
+
+#ifdef ENABLE_SERIAL_TXX9_PCI
+static int __devinit serial_txx9_init_one(struct pci_dev *dev,
+ const struct pci_device_id *ent)
+{
+ int rc, i;
+ struct rs_port *port;
+
+ rc = pci_enable_device(dev);
+ if (rc) return rc;
+
+ /* find empty slot */
+ for (i = 0; i < NR_PORTS && rs_ports[i].base; i++)
+ ;
+ if (i == NR_PORTS)
+ return -ENODEV;
+ port = &rs_ports[i];
+ DBG("port number is %d\n",i);
+
+ port->pci_dev = dev;
+ port->base = pci_resource_start(dev, 1);
+
+ DBG("port->base is %x\n",(u32)port->base);
+ port->io_type = SERIAL_IO_PORT;
+ port->irq = dev->irq;
+ port->flags |= TXX9_SERIAL_HAVE_CTS_LINE;
+ port->baud_base = 66670000 / 16 / 2; /* 66.67MHz */
+ DBG("port->baud_base %x\n",port->baud_base);
+
+ txx9_config(port);
+
+ printk(KERN_INFO
+ "%s%d at 0x%08lx (irq = %d) is a TX39/49 SIO\n",
+ TXX9_TTY_NAME, i, port->base, port->irq);
+ return 0;
+}
+
+static void __devexit serial_txx9_remove_one(struct pci_dev *dev)
+{
+ int i;
+ for (i = 0; i < NR_PORTS; i++) {
+ if (rs_ports[i].pci_dev == dev) {
+ rs_ports[i].irq = 0;
+ rs_ports[i].base = 0;
+ rs_ports[i].pci_dev = 0;
+ /* XXX NOT IMPLEMENTED YET */
+ break;
+ }
+ }
+}
+
+static struct pci_device_id serial_txx9_pci_tbl[] __devinitdata = {
+#ifdef PCI_DEVICE_ID_TOSHIBA_TC86C001_MISC
+ { PCI_VENDOR_ID_TOSHIBA_2, PCI_DEVICE_ID_TOSHIBA_TC86C001_MISC,
+ PCI_ANY_ID, PCI_ANY_ID, 0, 0,
+ 0 },
+#endif
+ { 0, }
+};
+
+MODULE_DEVICE_TABLE(pci, serial_txx9_pci_tbl);
+
+static struct pci_driver serial_txx9_pci_driver = {
+ name: "serial_txx9",
+ probe: serial_txx9_init_one,
+ remove: __devexit_p(serial_txx9_remove_one),
+ id_table: serial_txx9_pci_tbl,
+};
+
+/*
+ * Query PCI space for known serial boards
+ * If found, add them to the PCI device space in rs_table[]
+ */
+static void __devinit probe_serial_txx9_pci(void)
+{
+ /* 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_txx9_pci_driver) != 0)
+ serial_txx9_pci_driver.name = "";
+
+ return;
+}
+#endif /* ENABLE_SERIAL_TXX9_PCI */
+
+static int __init txx9_rs_init(void)
+{
+ int rc;
+ struct rs_port *port;
+ int i;
+
+#ifndef ENABLE_SERIAL_TXX9_PCI
+ for (i = 0, port = &rs_ports[0]; i < NR_PORTS; i++,port++) {
+ if (port->base)
+ goto config_ok;
+ }
+ return -ENODEV;
+ config_ok:
+#endif
+
+ show_serial_version();
+ rc = rs_init_portstructs ();
+ rs_init_drivers ();
+ for (i = 0, port = &rs_ports[0]; i < NR_PORTS; i++,port++) {
+ if (!port->base)
+ continue;
+ if (port->io_type < 0) {
+ if (check_mem_region(port->base, 36))
+ continue;
+ } else {
+ if (check_region(port->base, 36))
+ continue;
+ }
+ txx9_config(port);
+ printk(KERN_INFO
+ "%s%d at 0x%08lx (irq = %d) is a TX39/49 SIO\n",
+ TXX9_TTY_NAME, i, port->base, port->irq);
+ }
+
+ /* Note: I didn't do anything to enable the second UART */
+ if (rc >= 0)
+ rs_initialized++;
+
+#ifdef ENABLE_SERIAL_TXX9_PCI
+ probe_serial_txx9_pci();
+#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_txx9_setup(int line, unsigned long base, int irq,
+ int baud_base, int have_cts)
+{
+ if (line >= NR_PORTS)
+ return(-ENOENT);
+ rs_ports[line].base = base;
+ rs_ports[line].irq = irq;
+ rs_ports[line].baud_base = baud_base;
+ rs_ports[line].io_type = -1; /* virtual memory mapped */
+ if (have_cts)
+ rs_ports[line].flags |= TXX9_SERIAL_HAVE_CTS_LINE;
+ return(0);
+}
+
+static void __exit txx9_rs_fini(void)
+{
+ unsigned long flags;
+ int e1, e2;
+ int i;
+
+ local_irq_save(flags);
+ if ((e1 = tty_unregister_driver(&rs_driver)))
+ printk("serial: failed to unregister serial driver (%d)\n",
+ e1);
+ if ((e2 = tty_unregister_driver(&rs_callout_driver)))
+ printk("serial: failed to unregister callout driver (%d)\n",
+ e2);
+ local_irq_restore(flags);
+
+ for (i = 0; i < NR_PORTS; i++) {
+ if (!rs_ports[i].base)
+ continue;
+ if (rs_ports[i].io_type < 0)
+ release_mem_region(rs_ports[i].base, 36);
+ else
+ release_region(rs_ports[i].base, 36);
+ }
+
+#ifdef ENABLE_SERIAL_PCI
+ if (serial_txx9_pci_driver.name[0])
+ pci_unregister_driver (&serial_txx9_pci_driver);
+#endif
+}
+
+module_init(txx9_rs_init);
+module_exit(txx9_rs_fini);
+MODULE_DESCRIPTION("TX39/49 serial driver");
+MODULE_AUTHOR("TOSHIBA Corporation");
+MODULE_LICENSE("GPL");
+
+/*
+ * Begin serial console routines
+ */
+#ifdef CONFIG_SERIAL_TXX9_CONSOLE
+
+/*
+ * Wait for transmitter & holding register to empty
+ */
+static inline void wait_for_xmitr(struct rs_port *port)
+{
+ unsigned int tmout = 1000000;
+
+ do {
+ if (--tmout == 0) break;
+ } while (!(sio_in(port, TXX9_SICISR) & TXX9_SICISR_TXALS));
+
+ /* Wait for flow control if necessary */
+#if (ASYNC_INTERNAL_FLAGS & GS_INTERNAL_FLAGS) == 0 /* check conflict... */
+ if (port->gs.flags & ASYNC_CONS_FLOW) {
+ tmout = 1000000;
+ while (--tmout &&
+ (sio_in(port, TXX9_SICISR) & TXX9_SICISR_CTSS));
+ }
+#endif
+}
+
+/*
+ * Print a string to the serial port trying not to disturb
+ * any possible real use of the port...
+ *
+ * The console_lock must be held when we get here.
+ */
+static void serial_console_write(struct console *co, const char *s,
+ unsigned count)
+{
+ struct rs_port *port = &rs_ports[co->index];
+ int ier;
+ unsigned i;
+
+ /*
+ * First save the IER then disable the interrupts
+ */
+ ier = sio_in(port, TXX9_SIDICR);
+ sio_out(port, TXX9_SIDICR, 0);
+
+ /*
+ * Now, do each character
+ */
+ for (i = 0; i < count; i++, s++) {
+ wait_for_xmitr(port);
+
+ /*
+ * Send the character out.
+ * If a LF, also do CR...
+ */
+ sio_out(port, TXX9_SITFIFO, *s);
+ if (*s == 10) {
+ wait_for_xmitr(port);
+ sio_out(port, TXX9_SITFIFO, 13);
+ }
+ }
+
+ /*
+ * Finally, Wait for transmitter & holding register to empty
+ * and restore the IER
+ */
+ wait_for_xmitr(port);
+ sio_out(port, TXX9_SIDICR, ier);
+}
+
+static kdev_t serial_console_device(struct console *c)
+{
+ return MKDEV(TXX9_TTY_MAJOR, TXX9_TTY_MINOR_START + c->index);
+}
+
+static __init int serial_console_setup(struct console *co, char *options)
+{
+ struct rs_port *port;
+ 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 (co->index < 0 || co->index >= NR_PORTS)
+ return -1;
+ 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;
+ default:
+ /*
+ * Set this to a sane value to prevent a divide error
+ */
+ baud = 9600;
+ case 9600: cflag |= B9600; 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;
+
+ port = &rs_ports[co->index];
+ if (!port->base)
+ return -1;
+
+ /*
+ * Divisor, bytesize and parity
+ */
+#if (ASYNC_INTERNAL_FLAGS & GS_INTERNAL_FLAGS) == 0 /* check conflict... */
+ if (doflow)
+ port->gs.flags |= ASYNC_CONS_FLOW;
+#endif
+ quot = port->baud_base / baud;
+ switch (cflag & CSIZE) {
+ case CS7: cval = TXX9_SILCR_UMODE_7BIT; break;
+ default:
+ case CS8: cval = TXX9_SILCR_UMODE_8BIT; break;
+ }
+ if (cflag & CSTOPB)
+ cval |= TXX9_SILCR_USBL_2BIT;
+ else
+ cval |= TXX9_SILCR_USBL_1BIT;
+ if (cflag & PARENB)
+ cval |= TXX9_SILCR_UPEN;
+ if (!(cflag & PARODD))
+ cval |= TXX9_SILCR_UEPS;
+
+ /*
+ * Disable UART interrupts, set DTR and RTS high
+ * and set speed.
+ */
+ sio_out(port, TXX9_SIDICR, 0);
+ sio_out(port, TXX9_SILCR, cval | TXX9_SILCR_SCS_IMCLK_BG);
+ sio_out(port, TXX9_SIBGR, quot | TXX9_SIBGR_BCLK_T0);
+ /* no RTS/CTS control */
+ sio_out(port, TXX9_SIFLCR, TXX9_SIFLCR_RTSTL_MAX /* 15 */);
+ /* Enable RX/TX */
+ sio_mask(port, TXX9_SIFLCR, TXX9_SIFLCR_RSDE | TXX9_SIFLCR_TSDE);
+
+ /* console port should not use RTC/CTS. */
+ port->flags &= ~TXX9_SERIAL_HAVE_CTS_LINE;
+ return 0;
+}
+
+static struct console sercons = {
+ name: TXX9_TTY_NAME,
+ write: serial_console_write,
+ device: serial_console_device,
+ setup: serial_console_setup,
+ flags: CON_PRINTBUFFER,
+ index: -1,
+};
+
+void __init txx9_serial_console_init(void)
+{
+ register_console(&sercons);
+}
+
+#endif
+
+/******************************************************************************/
+/* BEG: KDBG Routines */
+/******************************************************************************/
+
+#ifdef CONFIG_KGDB
+int kgdb_init_count = 0;
+#endif
+
+#ifdef CONFIG_KGDB
+void txx9_sio_kgdb_hook(unsigned int port, unsigned int baud_rate)
+{
+ static struct resource kgdb_resource;
+ int ret;
+
+ /* prevent initialization by driver */
+ kgdb_resource.name = "serial_txx9(debug)";
+ kgdb_resource.start = rs_ports[port].base;
+ kgdb_resource.end = rs_ports[port].base + 36 - 1;
+ kgdb_resource.flags = IORESOURCE_MEM | IORESOURCE_BUSY;
+
+ ret = request_resource(&iomem_resource, &kgdb_resource);
+ if(ret == -EBUSY)
+ printk(" serial_txx9(debug): request_resource failed\n");
+
+ return;
+}
+#endif /* CONFIG_KGDB */
+
+#ifdef CONFIG_KGDB
+void
+txx9_sio_kdbg_init( unsigned int port_number )
+{
+ if ( port_number == 1 ) {
+ txx9_sio_kgdb_hook( port_number, 38400 );
+ } else {
+ printk("Bad Port Number [%u] != [1]\n",port_number);
+ }
+ return;
+}
+#endif /* CONFIG_KGDB */
+
+#ifdef CONFIG_KGDB
+u8
+txx9_sio_kdbg_rd( void )
+{
+ unsigned int status,ch;
+
+ if ( kgdb_init_count == 0 )
+ {
+ txx9_sio_kdbg_init( 1 );
+ kgdb_init_count = 1;
+ }
+
+ while ( 1 )
+ {
+ status = sio_in(&rs_ports[1], TXX9_SIDISR);
+ if ( status & 0x1f )
+ {
+ ch = sio_in(&rs_ports[1], TXX9_SIRFIFO );
+ break;
+ }
+ }
+
+ return( ch );
+}
+#endif /* CONFIG_KGDB */
+
+#ifdef CONFIG_KGDB
+int
+txx9_sio_kdbg_wr( u8 ch )
+{
+ unsigned int status;
+
+ if ( kgdb_init_count == 0 )
+ {
+ txx9_sio_kdbg_init( 1 );
+ kgdb_init_count = 1;
+ }
+
+ while ( 1 )
+ {
+ status = sio_in(&rs_ports[1], TXX9_SICISR);
+ if (status & TXX9_SICISR_TRDY)
+ {
+ if ( ch == '\n' )
+ {
+ txx9_sio_kdbg_wr( '\r' );
+ }
+ sio_out(&rs_ports[1], TXX9_SITFIFO, (u32)ch );
+
+ break;
+ }
+ }
+
+ return( 1 );
+}
+#endif /* CONFIG_KGDB */
+
+/******************************************************************************/
+/* END: KDBG Routines */
+/******************************************************************************/
+
+void txx9_raw_output(char c)
+{
+ struct rs_port *port = &rs_ports[0];
+ if ( c == '\n' )
+ {
+ sio_out(port, TXX9_SITFIFO, '\r');
+ wait_for_xmitr(port);
+ }
+ sio_out(port, TXX9_SITFIFO, c);
+ wait_for_xmitr(port);
+ return;
+}
FUNET's LINUX-ADM group, linux-adm@nic.funet.fi
TCL-scripts by Sam Shen (who was at: slshen@lbl.gov)