/* * drivers/char/serial_txx9.c * * Copyright (C) 1999 Harald Koerfgen * Copyright (C) 2000 Jim Pick * 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 #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef CONFIG_MAGIC_SYSRQ #include #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; }