URL https://opencores.org/ocsvn/or1k/or1k/trunk
Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [serial_txx9.c] - Blame information for rev 1774

Go to most recent revision | Details | Compare with Previous | View Log

/*
 *  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,
 
#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;
}
Browse

Tools

Subversion Repositories or1k

[/] [or1k/] [trunk/] [linux/] [linux-2.4/] [drivers/] [char/] [serial_txx9.c] - Blame information for rev 1774

Line No.	Rev	Author	Line
1	1275	phoenix	`/*`
2			`* drivers/char/serial_txx9.c`
3			`*`
4			`* Copyright (C) 1999 Harald Koerfgen`
5			`* Copyright (C) 2000 Jim Pick <jim@jimpick.com>`
6			`* Copyright (C) 2001 Steven J. Hill (sjhill@realitydiluted.com)`
7			`* Copyright (C) 2000-2002 Toshiba Corporation`
8			`*`
9			`* This program is free software; you can redistribute it and/or modify`
10			`* it under the terms of the GNU General Public License version 2 as`
11			`* published by the Free Software Foundation.`
12			`*`
13			`* Serial driver for TX3927/TX4927/TX4925/TX4938 internal SIO controller`
14			`*/`
15			`#include <linux/init.h>`
16			`#include <linux/config.h>`
17			`#include <linux/tty.h>`
18			`#include <linux/major.h>`
19			`#include <linux/ptrace.h>`
20			`#include <linux/init.h>`
21			`#include <linux/console.h>`
22			`#include <linux/fs.h>`
23			`#include <linux/mm.h>`
24			`#include <linux/ioport.h>`
25			`#include <linux/module.h>`
26			`#include <linux/delay.h>`
27			`#include <linux/pm.h>`
28			`#include <asm/io.h>`
29			`#include <asm/uaccess.h>`
30			`#include <asm/delay.h>`
31			`#include <linux/serial.h>`
32			`#include <linux/generic_serial.h>`
33			`#include <linux/pci.h>`
34			`#ifdef CONFIG_MAGIC_SYSRQ`
35			`#include <linux/sysrq.h>`
36			`#endif`
37
38			`#define DEBUG`
39			`#ifdef DEBUG`
40			`#define DBG(x...) printk(x)`