| /* |
| * drivers/serial/serial_ks8695.c |
| * |
| * Driver for KS8695 serial ports |
| * |
| * Based on drivers/serial/serial_amba.c, by Kam Lee. |
| * |
| * Copyright 2002-2005 Micrel Inc. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| */ |
| #include <linux/module.h> |
| #include <linux/tty.h> |
| #include <linux/ioport.h> |
| #include <linux/init.h> |
| #include <linux/serial.h> |
| #include <linux/console.h> |
| #include <linux/sysrq.h> |
| #include <linux/device.h> |
| |
| #include <asm/io.h> |
| #include <asm/irq.h> |
| #include <asm/mach/irq.h> |
| |
| #include <asm/arch/regs-uart.h> |
| #include <asm/arch/regs-irq.h> |
| |
| #if defined(CONFIG_SERIAL_KS8695_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) |
| #define SUPPORT_SYSRQ |
| #endif |
| |
| #include <linux/serial_core.h> |
| |
| |
| #define SERIAL_KS8695_MAJOR 204 |
| #define SERIAL_KS8695_MINOR 16 |
| #define SERIAL_KS8695_DEVNAME "ttyAM" |
| |
| #define SERIAL_KS8695_NR 1 |
| |
| /* |
| * Access macros for the KS8695 UART |
| */ |
| #define UART_GET_CHAR(p) (__raw_readl((p)->membase + KS8695_URRB) & 0xFF) |
| #define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + KS8695_URTH) |
| #define UART_GET_FCR(p) __raw_readl((p)->membase + KS8695_URFC) |
| #define UART_PUT_FCR(p, c) __raw_writel((c), (p)->membase + KS8695_URFC) |
| #define UART_GET_MSR(p) __raw_readl((p)->membase + KS8695_URMS) |
| #define UART_GET_LSR(p) __raw_readl((p)->membase + KS8695_URLS) |
| #define UART_GET_LCR(p) __raw_readl((p)->membase + KS8695_URLC) |
| #define UART_PUT_LCR(p, c) __raw_writel((c), (p)->membase + KS8695_URLC) |
| #define UART_GET_MCR(p) __raw_readl((p)->membase + KS8695_URMC) |
| #define UART_PUT_MCR(p, c) __raw_writel((c), (p)->membase + KS8695_URMC) |
| #define UART_GET_BRDR(p) __raw_readl((p)->membase + KS8695_URBD) |
| #define UART_PUT_BRDR(p, c) __raw_writel((c), (p)->membase + KS8695_URBD) |
| |
| #define KS8695_CLR_TX_INT() __raw_writel(1 << KS8695_IRQ_UART_TX, KS8695_IRQ_VA + KS8695_INTST) |
| |
| #define UART_DUMMY_LSR_RX 0x100 |
| #define UART_PORT_SIZE (KS8695_USR - KS8695_URRB + 4) |
| |
| #define tx_enabled(port) ((port)->unused[0]) |
| #define rx_enabled(port) ((port)->unused[1]) |
| |
| |
| #ifdef SUPPORT_SYSRQ |
| static struct console ks8695_console; |
| #endif |
| |
| static void ks8695uart_stop_tx(struct uart_port *port) |
| { |
| if (tx_enabled(port)) { |
| disable_irq(KS8695_IRQ_UART_TX); |
| tx_enabled(port) = 0; |
| } |
| } |
| |
| static void ks8695uart_start_tx(struct uart_port *port) |
| { |
| if (!tx_enabled(port)) { |
| enable_irq(KS8695_IRQ_UART_TX); |
| tx_enabled(port) = 1; |
| } |
| } |
| |
| static void ks8695uart_stop_rx(struct uart_port *port) |
| { |
| if (rx_enabled(port)) { |
| disable_irq(KS8695_IRQ_UART_RX); |
| rx_enabled(port) = 0; |
| } |
| } |
| |
| static void ks8695uart_enable_ms(struct uart_port *port) |
| { |
| enable_irq(KS8695_IRQ_UART_MODEM_STATUS); |
| } |
| |
| static void ks8695uart_disable_ms(struct uart_port *port) |
| { |
| disable_irq(KS8695_IRQ_UART_MODEM_STATUS); |
| } |
| |
| static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id) |
| { |
| struct uart_port *port = dev_id; |
| struct tty_struct *tty = port->info->tty; |
| unsigned int status, ch, lsr, flg, max_count = 256; |
| |
| status = UART_GET_LSR(port); /* clears pending LSR interrupts */ |
| while ((status & URLS_URDR) && max_count--) { |
| ch = UART_GET_CHAR(port); |
| flg = TTY_NORMAL; |
| |
| port->icount.rx++; |
| |
| /* |
| * Note that the error handling code is |
| * out of the main execution path |
| */ |
| lsr = UART_GET_LSR(port) | UART_DUMMY_LSR_RX; |
| if (unlikely(lsr & (URLS_URBI | URLS_URPE | URLS_URFE | URLS_URROE))) { |
| if (lsr & URLS_URBI) { |
| lsr &= ~(URLS_URFE | URLS_URPE); |
| port->icount.brk++; |
| if (uart_handle_break(port)) |
| goto ignore_char; |
| } |
| if (lsr & URLS_URPE) |
| port->icount.parity++; |
| if (lsr & URLS_URFE) |
| port->icount.frame++; |
| if (lsr & URLS_URROE) |
| port->icount.overrun++; |
| |
| lsr &= port->read_status_mask; |
| |
| if (lsr & URLS_URBI) |
| flg = TTY_BREAK; |
| else if (lsr & URLS_URPE) |
| flg = TTY_PARITY; |
| else if (lsr & URLS_URFE) |
| flg = TTY_FRAME; |
| } |
| |
| if (uart_handle_sysrq_char(port, ch)) |
| goto ignore_char; |
| |
| uart_insert_char(port, lsr, URLS_URROE, ch, flg); |
| |
| ignore_char: |
| status = UART_GET_LSR(port); |
| } |
| tty_flip_buffer_push(tty); |
| |
| return IRQ_HANDLED; |
| } |
| |
| |
| static irqreturn_t ks8695uart_tx_chars(int irq, void *dev_id) |
| { |
| struct uart_port *port = dev_id; |
| struct circ_buf *xmit = &port->info->xmit; |
| unsigned int count; |
| |
| if (port->x_char) { |
| KS8695_CLR_TX_INT(); |
| UART_PUT_CHAR(port, port->x_char); |
| port->icount.tx++; |
| port->x_char = 0; |
| return IRQ_HANDLED; |
| } |
| |
| if (uart_tx_stopped(port) || uart_circ_empty(xmit)) { |
| ks8695uart_stop_tx(port); |
| return IRQ_HANDLED; |
| } |
| |
| count = 16; /* fifo size */ |
| while (!uart_circ_empty(xmit) && (count-- > 0)) { |
| KS8695_CLR_TX_INT(); |
| UART_PUT_CHAR(port, xmit->buf[xmit->tail]); |
| |
| xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); |
| port->icount.tx++; |
| } |
| |
| if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) |
| uart_write_wakeup(port); |
| |
| if (uart_circ_empty(xmit)) |
| ks8695uart_stop_tx(port); |
| |
| return IRQ_HANDLED; |
| } |
| |
| static irqreturn_t ks8695uart_modem_status(int irq, void *dev_id) |
| { |
| struct uart_port *port = dev_id; |
| unsigned int status; |
| |
| /* |
| * clear modem interrupt by reading MSR |
| */ |
| status = UART_GET_MSR(port); |
| |
| if (status & URMS_URDDCD) |
| uart_handle_dcd_change(port, status & URMS_URDDCD); |
| |
| if (status & URMS_URDDST) |
| port->icount.dsr++; |
| |
| if (status & URMS_URDCTS) |
| uart_handle_cts_change(port, status & URMS_URDCTS); |
| |
| if (status & URMS_URTERI) |
| port->icount.rng++; |
| |
| wake_up_interruptible(&port->info->delta_msr_wait); |
| |
| return IRQ_HANDLED; |
| } |
| |
| static unsigned int ks8695uart_tx_empty(struct uart_port *port) |
| { |
| return (UART_GET_LSR(port) & URLS_URTE) ? TIOCSER_TEMT : 0; |
| } |
| |
| static unsigned int ks8695uart_get_mctrl(struct uart_port *port) |
| { |
| unsigned int result = 0; |
| unsigned int status; |
| |
| status = UART_GET_MSR(port); |
| if (status & URMS_URDCD) |
| result |= TIOCM_CAR; |
| if (status & URMS_URDSR) |
| result |= TIOCM_DSR; |
| if (status & URMS_URCTS) |
| result |= TIOCM_CTS; |
| if (status & URMS_URRI) |
| result |= TIOCM_RI; |
| |
| return result; |
| } |
| |
| static void ks8695uart_set_mctrl(struct uart_port *port, u_int mctrl) |
| { |
| unsigned int mcr; |
| |
| mcr = UART_GET_MCR(port); |
| if (mctrl & TIOCM_RTS) |
| mcr |= URMC_URRTS; |
| else |
| mcr &= ~URMC_URRTS; |
| |
| if (mctrl & TIOCM_DTR) |
| mcr |= URMC_URDTR; |
| else |
| mcr &= ~URMC_URDTR; |
| |
| UART_PUT_MCR(port, mcr); |
| } |
| |
| static void ks8695uart_break_ctl(struct uart_port *port, int break_state) |
| { |
| unsigned int lcr; |
| |
| lcr = UART_GET_LCR(port); |
| |
| if (break_state == -1) |
| lcr |= URLC_URSBC; |
| else |
| lcr &= ~URLC_URSBC; |
| |
| UART_PUT_LCR(port, lcr); |
| } |
| |
| static int ks8695uart_startup(struct uart_port *port) |
| { |
| int retval; |
| |
| set_irq_flags(KS8695_IRQ_UART_TX, IRQF_VALID | IRQF_NOAUTOEN); |
| tx_enabled(port) = 0; |
| rx_enabled(port) = 1; |
| |
| /* |
| * Allocate the IRQ |
| */ |
| retval = request_irq(KS8695_IRQ_UART_TX, ks8695uart_tx_chars, IRQF_DISABLED, "UART TX", port); |
| if (retval) |
| goto err_tx; |
| |
| retval = request_irq(KS8695_IRQ_UART_RX, ks8695uart_rx_chars, IRQF_DISABLED, "UART RX", port); |
| if (retval) |
| goto err_rx; |
| |
| retval = request_irq(KS8695_IRQ_UART_LINE_STATUS, ks8695uart_rx_chars, IRQF_DISABLED, "UART LineStatus", port); |
| if (retval) |
| goto err_ls; |
| |
| retval = request_irq(KS8695_IRQ_UART_MODEM_STATUS, ks8695uart_modem_status, IRQF_DISABLED, "UART ModemStatus", port); |
| if (retval) |
| goto err_ms; |
| |
| return 0; |
| |
| err_ms: |
| free_irq(KS8695_IRQ_UART_LINE_STATUS, port); |
| err_ls: |
| free_irq(KS8695_IRQ_UART_RX, port); |
| err_rx: |
| free_irq(KS8695_IRQ_UART_TX, port); |
| err_tx: |
| return retval; |
| } |
| |
| static void ks8695uart_shutdown(struct uart_port *port) |
| { |
| /* |
| * Free the interrupt |
| */ |
| free_irq(KS8695_IRQ_UART_RX, port); |
| free_irq(KS8695_IRQ_UART_TX, port); |
| free_irq(KS8695_IRQ_UART_MODEM_STATUS, port); |
| free_irq(KS8695_IRQ_UART_LINE_STATUS, port); |
| |
| /* disable break condition and fifos */ |
| UART_PUT_LCR(port, UART_GET_LCR(port) & ~URLC_URSBC); |
| UART_PUT_FCR(port, UART_GET_FCR(port) & ~URFC_URFE); |
| } |
| |
| static void ks8695uart_set_termios(struct uart_port *port, struct ktermios *termios, struct ktermios *old) |
| { |
| unsigned int lcr, fcr = 0; |
| unsigned long flags; |
| unsigned int baud, quot; |
| |
| /* |
| * Ask the core to calculate the divisor for us. |
| */ |
| baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16); |
| quot = uart_get_divisor(port, baud); |
| |
| switch (termios->c_cflag & CSIZE) { |
| case CS5: |
| lcr = URCL_5; |
| break; |
| case CS6: |
| lcr = URCL_6; |
| break; |
| case CS7: |
| lcr = URCL_7; |
| break; |
| default: |
| lcr = URCL_8; |
| break; |
| } |
| |
| /* stop bits */ |
| if (termios->c_cflag & CSTOPB) |
| lcr |= URLC_URSB; |
| |
| /* parity */ |
| if (termios->c_cflag & PARENB) { |
| if (termios->c_cflag & CMSPAR) { /* Mark or Space parity */ |
| if (termios->c_cflag & PARODD) |
| lcr |= URPE_MARK; |
| else |
| lcr |= URPE_SPACE; |
| } |
| else if (termios->c_cflag & PARODD) |
| lcr |= URPE_ODD; |
| else |
| lcr |= URPE_EVEN; |
| } |
| |
| if (port->fifosize > 1) |
| fcr = URFC_URFRT_8 | URFC_URTFR | URFC_URRFR | URFC_URFE; |
| |
| spin_lock_irqsave(&port->lock, flags); |
| |
| /* |
| * Update the per-port timeout. |
| */ |
| uart_update_timeout(port, termios->c_cflag, baud); |
| |
| port->read_status_mask = URLS_URROE; |
| if (termios->c_iflag & INPCK) |
| port->read_status_mask |= (URLS_URFE | URLS_URPE); |
| if (termios->c_iflag & (BRKINT | PARMRK)) |
| port->read_status_mask |= URLS_URBI; |
| |
| /* |
| * Characters to ignore |
| */ |
| port->ignore_status_mask = 0; |
| if (termios->c_iflag & IGNPAR) |
| port->ignore_status_mask |= (URLS_URFE | URLS_URPE); |
| if (termios->c_iflag & IGNBRK) { |
| port->ignore_status_mask |= URLS_URBI; |
| /* |
| * If we're ignoring parity and break indicators, |
| * ignore overruns too (for real raw support). |
| */ |
| if (termios->c_iflag & IGNPAR) |
| port->ignore_status_mask |= URLS_URROE; |
| } |
| |
| /* |
| * Ignore all characters if CREAD is not set. |
| */ |
| if ((termios->c_cflag & CREAD) == 0) |
| port->ignore_status_mask |= UART_DUMMY_LSR_RX; |
| |
| /* first, disable everything */ |
| if (UART_ENABLE_MS(port, termios->c_cflag)) |
| ks8695uart_enable_ms(port); |
| else |
| ks8695uart_disable_ms(port); |
| |
| /* Set baud rate */ |
| UART_PUT_BRDR(port, quot); |
| |
| UART_PUT_LCR(port, lcr); |
| UART_PUT_FCR(port, fcr); |
| |
| spin_unlock_irqrestore(&port->lock, flags); |
| } |
| |
| static const char *ks8695uart_type(struct uart_port *port) |
| { |
| return port->type == PORT_KS8695 ? "KS8695" : NULL; |
| } |
| |
| /* |
| * Release the memory region(s) being used by 'port' |
| */ |
| static void ks8695uart_release_port(struct uart_port *port) |
| { |
| release_mem_region(port->mapbase, UART_PORT_SIZE); |
| } |
| |
| /* |
| * Request the memory region(s) being used by 'port' |
| */ |
| static int ks8695uart_request_port(struct uart_port *port) |
| { |
| return request_mem_region(port->mapbase, UART_PORT_SIZE, |
| "serial_ks8695") != NULL ? 0 : -EBUSY; |
| } |
| |
| /* |
| * Configure/autoconfigure the port. |
| */ |
| static void ks8695uart_config_port(struct uart_port *port, int flags) |
| { |
| if (flags & UART_CONFIG_TYPE) { |
| port->type = PORT_KS8695; |
| ks8695uart_request_port(port); |
| } |
| } |
| |
| /* |
| * verify the new serial_struct (for TIOCSSERIAL). |
| */ |
| static int ks8695uart_verify_port(struct uart_port *port, struct serial_struct *ser) |
| { |
| int ret = 0; |
| |
| if (ser->type != PORT_UNKNOWN && ser->type != PORT_KS8695) |
| ret = -EINVAL; |
| if (ser->irq != port->irq) |
| ret = -EINVAL; |
| if (ser->baud_base < 9600) |
| ret = -EINVAL; |
| return ret; |
| } |
| |
| static struct uart_ops ks8695uart_pops = { |
| .tx_empty = ks8695uart_tx_empty, |
| .set_mctrl = ks8695uart_set_mctrl, |
| .get_mctrl = ks8695uart_get_mctrl, |
| .stop_tx = ks8695uart_stop_tx, |
| .start_tx = ks8695uart_start_tx, |
| .stop_rx = ks8695uart_stop_rx, |
| .enable_ms = ks8695uart_enable_ms, |
| .break_ctl = ks8695uart_break_ctl, |
| .startup = ks8695uart_startup, |
| .shutdown = ks8695uart_shutdown, |
| .set_termios = ks8695uart_set_termios, |
| .type = ks8695uart_type, |
| .release_port = ks8695uart_release_port, |
| .request_port = ks8695uart_request_port, |
| .config_port = ks8695uart_config_port, |
| .verify_port = ks8695uart_verify_port, |
| }; |
| |
| static struct uart_port ks8695uart_ports[SERIAL_KS8695_NR] = { |
| { |
| .membase = (void *) KS8695_UART_VA, |
| .mapbase = KS8695_UART_VA, |
| .iotype = SERIAL_IO_MEM, |
| .irq = KS8695_IRQ_UART_TX, |
| .uartclk = CLOCK_TICK_RATE * 16, |
| .fifosize = 16, |
| .ops = &ks8695uart_pops, |
| .flags = ASYNC_BOOT_AUTOCONF, |
| .line = 0, |
| } |
| }; |
| |
| #ifdef CONFIG_SERIAL_KS8695_CONSOLE |
| static void ks8695_console_putchar(struct uart_port *port, int ch) |
| { |
| while (!(UART_GET_LSR(port) & URLS_URTHRE)) |
| barrier(); |
| |
| UART_PUT_CHAR(port, ch); |
| } |
| |
| static void ks8695_console_write(struct console *co, const char *s, u_int count) |
| { |
| struct uart_port *port = ks8695uart_ports + co->index; |
| |
| uart_console_write(port, s, count, ks8695_console_putchar); |
| } |
| |
| static void __init ks8695_console_get_options(struct uart_port *port, int *baud, int *parity, int *bits) |
| { |
| unsigned int lcr; |
| |
| lcr = UART_GET_LCR(port); |
| |
| switch (lcr & URLC_PARITY) { |
| case URPE_ODD: |
| *parity = 'o'; |
| break; |
| case URPE_EVEN: |
| *parity = 'e'; |
| break; |
| default: |
| *parity = 'n'; |
| } |
| |
| switch (lcr & URLC_URCL) { |
| case URCL_5: |
| *bits = 5; |
| break; |
| case URCL_6: |
| *bits = 6; |
| break; |
| case URCL_7: |
| *bits = 7; |
| break; |
| default: |
| *bits = 8; |
| } |
| |
| *baud = port->uartclk / (UART_GET_BRDR(port) & 0x0FFF); |
| *baud /= 16; |
| *baud &= 0xFFFFFFF0; |
| } |
| |
| static int __init ks8695_console_setup(struct console *co, char *options) |
| { |
| struct uart_port *port; |
| int baud = 115200; |
| int bits = 8; |
| int parity = 'n'; |
| int flow = 'n'; |
| |
| /* |
| * Check whether an invalid uart number has been specified, and |
| * if so, search for the first available port that does have |
| * console support. |
| */ |
| port = uart_get_console(ks8695uart_ports, SERIAL_KS8695_NR, co); |
| |
| if (options) |
| uart_parse_options(options, &baud, &parity, &bits, &flow); |
| else |
| ks8695_console_get_options(port, &baud, &parity, &bits); |
| |
| return uart_set_options(port, co, baud, parity, bits, flow); |
| } |
| |
| static struct uart_driver ks8695_reg; |
| |
| static struct console ks8695_console = { |
| .name = SERIAL_KS8695_DEVNAME, |
| .write = ks8695_console_write, |
| .device = uart_console_device, |
| .setup = ks8695_console_setup, |
| .flags = CON_PRINTBUFFER, |
| .index = -1, |
| .data = &ks8695_reg, |
| }; |
| |
| static int __init ks8695_console_init(void) |
| { |
| register_console(&ks8695_console); |
| return 0; |
| } |
| |
| console_initcall(ks8695_console_init); |
| |
| #define KS8695_CONSOLE &ks8695_console |
| #else |
| #define KS8695_CONSOLE NULL |
| #endif |
| |
| static struct uart_driver ks8695_reg = { |
| .owner = THIS_MODULE, |
| .driver_name = "serial_ks8695", |
| .dev_name = SERIAL_KS8695_DEVNAME, |
| .major = SERIAL_KS8695_MAJOR, |
| .minor = SERIAL_KS8695_MINOR, |
| .nr = SERIAL_KS8695_NR, |
| .cons = KS8695_CONSOLE, |
| }; |
| |
| static int __init ks8695uart_init(void) |
| { |
| int i, ret; |
| |
| printk(KERN_INFO "Serial: Micrel KS8695 UART driver\n"); |
| |
| ret = uart_register_driver(&ks8695_reg); |
| if (ret) |
| return ret; |
| |
| for (i = 0; i < SERIAL_KS8695_NR; i++) |
| uart_add_one_port(&ks8695_reg, &ks8695uart_ports[0]); |
| |
| return 0; |
| } |
| |
| static void __exit ks8695uart_exit(void) |
| { |
| int i; |
| |
| for (i = 0; i < SERIAL_KS8695_NR; i++) |
| uart_remove_one_port(&ks8695_reg, &ks8695uart_ports[0]); |
| uart_unregister_driver(&ks8695_reg); |
| } |
| |
| module_init(ks8695uart_init); |
| module_exit(ks8695uart_exit); |
| |
| MODULE_DESCRIPTION("KS8695 serial port driver"); |
| MODULE_AUTHOR("Micrel Inc."); |
| MODULE_LICENSE("GPL"); |