1/* 2 * drivers/serial/serial_ks8695.c 3 * 4 * Driver for KS8695 serial ports 5 * 6 * Based on drivers/serial/serial_amba.c, by Kam Lee. 7 * 8 * Copyright 2002-2005 Micrel Inc. 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 */ 16#include <linux/module.h> 17#include <linux/tty.h> 18#include <linux/ioport.h> 19#include <linux/init.h> 20#include <linux/serial.h> 21#include <linux/console.h> 22#include <linux/sysrq.h> 23#include <linux/device.h> 24 25#include <asm/io.h> 26#include <asm/irq.h> 27#include <asm/mach/irq.h> 28 29#include <mach/regs-uart.h> 30#include <mach/regs-irq.h> 31 32#if defined(CONFIG_SERIAL_KS8695_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ) 33#define SUPPORT_SYSRQ 34#endif 35 36#include <linux/serial_core.h> 37 38 39#define SERIAL_KS8695_MAJOR 204 40#define SERIAL_KS8695_MINOR 16 41#define SERIAL_KS8695_DEVNAME "ttyAM" 42 43#define SERIAL_KS8695_NR 1 44 45/* 46 * Access macros for the KS8695 UART 47 */ 48#define UART_GET_CHAR(p) (__raw_readl((p)->membase + KS8695_URRB) & 0xFF) 49#define UART_PUT_CHAR(p, c) __raw_writel((c), (p)->membase + KS8695_URTH) 50#define UART_GET_FCR(p) __raw_readl((p)->membase + KS8695_URFC) 51#define UART_PUT_FCR(p, c) __raw_writel((c), (p)->membase + KS8695_URFC) 52#define UART_GET_MSR(p) __raw_readl((p)->membase + KS8695_URMS) 53#define UART_GET_LSR(p) __raw_readl((p)->membase + KS8695_URLS) 54#define UART_GET_LCR(p) __raw_readl((p)->membase + KS8695_URLC) 55#define UART_PUT_LCR(p, c) __raw_writel((c), (p)->membase + KS8695_URLC) 56#define UART_GET_MCR(p) __raw_readl((p)->membase + KS8695_URMC) 57#define UART_PUT_MCR(p, c) __raw_writel((c), (p)->membase + KS8695_URMC) 58#define UART_GET_BRDR(p) __raw_readl((p)->membase + KS8695_URBD) 59#define UART_PUT_BRDR(p, c) __raw_writel((c), (p)->membase + KS8695_URBD) 60 61#define KS8695_CLR_TX_INT() __raw_writel(1 << KS8695_IRQ_UART_TX, KS8695_IRQ_VA + KS8695_INTST) 62 63#define UART_DUMMY_LSR_RX 0x100 64#define UART_PORT_SIZE (KS8695_USR - KS8695_URRB + 4) 65 66static inline int tx_enabled(struct uart_port *port) 67{ 68 return port->unused[0] & 1; 69} 70 71static inline int rx_enabled(struct uart_port *port) 72{ 73 return port->unused[0] & 2; 74} 75 76static inline int ms_enabled(struct uart_port *port) 77{ 78 return port->unused[0] & 4; 79} 80 81static inline void ms_enable(struct uart_port *port, int enabled) 82{ 83 if(enabled) 84 port->unused[0] |= 4; 85 else 86 port->unused[0] &= ~4; 87} 88 89static inline void rx_enable(struct uart_port *port, int enabled) 90{ 91 if(enabled) 92 port->unused[0] |= 2; 93 else 94 port->unused[0] &= ~2; 95} 96 97static inline void tx_enable(struct uart_port *port, int enabled) 98{ 99 if(enabled) 100 port->unused[0] |= 1; 101 else 102 port->unused[0] &= ~1; 103} 104 105 106#ifdef SUPPORT_SYSRQ 107static struct console ks8695_console; 108#endif 109 110static void ks8695uart_stop_tx(struct uart_port *port) 111{ 112 if (tx_enabled(port)) { 113 /* use disable_irq_nosync() and not disable_irq() to avoid self 114 * imposed deadlock by not waiting for irq handler to end, 115 * since this ks8695uart_stop_tx() is called from interrupt context. 116 */ 117 disable_irq_nosync(KS8695_IRQ_UART_TX); 118 tx_enable(port, 0); 119 } 120} 121 122static void ks8695uart_start_tx(struct uart_port *port) 123{ 124 if (!tx_enabled(port)) { 125 enable_irq(KS8695_IRQ_UART_TX); 126 tx_enable(port, 1); 127 } 128} 129 130static void ks8695uart_stop_rx(struct uart_port *port) 131{ 132 if (rx_enabled(port)) { 133 disable_irq(KS8695_IRQ_UART_RX); 134 rx_enable(port, 0); 135 } 136} 137 138static void ks8695uart_enable_ms(struct uart_port *port) 139{ 140 if (!ms_enabled(port)) { 141 enable_irq(KS8695_IRQ_UART_MODEM_STATUS); 142 ms_enable(port,1); 143 } 144} 145 146static void ks8695uart_disable_ms(struct uart_port *port) 147{ 148 if (ms_enabled(port)) { 149 disable_irq(KS8695_IRQ_UART_MODEM_STATUS); 150 ms_enable(port,0); 151 } 152} 153 154static irqreturn_t ks8695uart_rx_chars(int irq, void *dev_id) 155{ 156 struct uart_port *port = dev_id; 157 struct tty_struct *tty = port->state->port.tty; 158 unsigned int status, ch, lsr, flg, max_count = 256; 159 160 status = UART_GET_LSR(port); /* clears pending LSR interrupts */ 161 while ((status & URLS_URDR) && max_count--) { 162 ch = UART_GET_CHAR(port); 163 flg = TTY_NORMAL; 164 165 port->icount.rx++; 166 167 /* 168 * Note that the error handling code is 169 * out of the main execution path 170 */ 171 lsr = UART_GET_LSR(port) | UART_DUMMY_LSR_RX; 172 if (unlikely(lsr & (URLS_URBI | URLS_URPE | URLS_URFE | URLS_URROE))) { 173 if (lsr & URLS_URBI) { 174 lsr &= ~(URLS_URFE | URLS_URPE); 175 port->icount.brk++; 176 if (uart_handle_break(port)) 177 goto ignore_char; 178 } 179 if (lsr & URLS_URPE) 180 port->icount.parity++; 181 if (lsr & URLS_URFE) 182 port->icount.frame++; 183 if (lsr & URLS_URROE) 184 port->icount.overrun++; 185 186 lsr &= port->read_status_mask; 187 188 if (lsr & URLS_URBI) 189 flg = TTY_BREAK; 190 else if (lsr & URLS_URPE) 191 flg = TTY_PARITY; 192 else if (lsr & URLS_URFE) 193 flg = TTY_FRAME; 194 } 195 196 if (uart_handle_sysrq_char(port, ch)) 197 goto ignore_char; 198 199 uart_insert_char(port, lsr, URLS_URROE, ch, flg); 200 201ignore_char: 202 status = UART_GET_LSR(port); 203 } 204 tty_flip_buffer_push(tty); 205 206 return IRQ_HANDLED; 207} 208 209 210static irqreturn_t ks8695uart_tx_chars(int irq, void *dev_id) 211{ 212 struct uart_port *port = dev_id; 213 struct circ_buf *xmit = &port->state->xmit; 214 unsigned int count; 215 216 if (port->x_char) { 217 KS8695_CLR_TX_INT(); 218 UART_PUT_CHAR(port, port->x_char); 219 port->icount.tx++; 220 port->x_char = 0; 221 return IRQ_HANDLED; 222 } 223 224 if (uart_tx_stopped(port) || uart_circ_empty(xmit)) { 225 ks8695uart_stop_tx(port); 226 return IRQ_HANDLED; 227 } 228 229 count = 16; /* fifo size */ 230 while (!uart_circ_empty(xmit) && (count-- > 0)) { 231 KS8695_CLR_TX_INT(); 232 UART_PUT_CHAR(port, xmit->buf[xmit->tail]); 233 234 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); 235 port->icount.tx++; 236 } 237 238 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 239 uart_write_wakeup(port); 240 241 if (uart_circ_empty(xmit)) 242 ks8695uart_stop_tx(port); 243 244 return IRQ_HANDLED; 245} 246 247static irqreturn_t ks8695uart_modem_status(int irq, void *dev_id) 248{ 249 struct uart_port *port = dev_id; 250 unsigned int status; 251 252 /* 253 * clear modem interrupt by reading MSR 254 */ 255 status = UART_GET_MSR(port); 256 257 if (status & URMS_URDDCD) 258 uart_handle_dcd_change(port, status & URMS_URDDCD); 259 260 if (status & URMS_URDDST) 261 port->icount.dsr++; 262 263 if (status & URMS_URDCTS) 264 uart_handle_cts_change(port, status & URMS_URDCTS); 265 266 if (status & URMS_URTERI) 267 port->icount.rng++; 268 269 wake_up_interruptible(&port->state->port.delta_msr_wait); 270 271 return IRQ_HANDLED; 272} 273 274static unsigned int ks8695uart_tx_empty(struct uart_port *port) 275{ 276 return (UART_GET_LSR(port) & URLS_URTE) ? TIOCSER_TEMT : 0; 277} 278 279static unsigned int ks8695uart_get_mctrl(struct uart_port *port) 280{ 281 unsigned int result = 0; 282 unsigned int status; 283 284 status = UART_GET_MSR(port); 285 if (status & URMS_URDCD) 286 result |= TIOCM_CAR; 287 if (status & URMS_URDSR) 288 result |= TIOCM_DSR; 289 if (status & URMS_URCTS) 290 result |= TIOCM_CTS; 291 if (status & URMS_URRI) 292 result |= TIOCM_RI; 293 294 return result; 295} 296 297static void ks8695uart_set_mctrl(struct uart_port *port, u_int mctrl) 298{ 299 unsigned int mcr; 300 301 mcr = UART_GET_MCR(port); 302 if (mctrl & TIOCM_RTS) 303 mcr |= URMC_URRTS; 304 else 305 mcr &= ~URMC_URRTS; 306 307 if (mctrl & TIOCM_DTR) 308 mcr |= URMC_URDTR; 309 else 310 mcr &= ~URMC_URDTR; 311 312 UART_PUT_MCR(port, mcr); 313} 314 315static void ks8695uart_break_ctl(struct uart_port *port, int break_state) 316{ 317 unsigned int lcr; 318 319 lcr = UART_GET_LCR(port); 320 321 if (break_state == -1) 322 lcr |= URLC_URSBC; 323 else 324 lcr &= ~URLC_URSBC; 325 326 UART_PUT_LCR(port, lcr); 327} 328 329static int ks8695uart_startup(struct uart_port *port) 330{ 331 int retval; 332 333 set_irq_flags(KS8695_IRQ_UART_TX, IRQF_VALID | IRQF_NOAUTOEN); 334 tx_enable(port, 0); 335 rx_enable(port, 1); 336 ms_enable(port, 1); 337 338 /* 339 * Allocate the IRQ 340 */ 341 retval = request_irq(KS8695_IRQ_UART_TX, ks8695uart_tx_chars, IRQF_DISABLED, "UART TX", port); 342 if (retval) 343 goto err_tx; 344 345 retval = request_irq(KS8695_IRQ_UART_RX, ks8695uart_rx_chars, IRQF_DISABLED, "UART RX", port); 346 if (retval) 347 goto err_rx; 348 349 retval = request_irq(KS8695_IRQ_UART_LINE_STATUS, ks8695uart_rx_chars, IRQF_DISABLED, "UART LineStatus", port); 350 if (retval) 351 goto err_ls; 352 353 retval = request_irq(KS8695_IRQ_UART_MODEM_STATUS, ks8695uart_modem_status, IRQF_DISABLED, "UART ModemStatus", port); 354 if (retval) 355 goto err_ms; 356 357 return 0; 358 359err_ms: 360 free_irq(KS8695_IRQ_UART_LINE_STATUS, port); 361err_ls: 362 free_irq(KS8695_IRQ_UART_RX, port); 363err_rx: 364 free_irq(KS8695_IRQ_UART_TX, port); 365err_tx: 366 return retval; 367} 368 369static void ks8695uart_shutdown(struct uart_port *port) 370{ 371 /* 372 * Free the interrupt 373 */ 374 free_irq(KS8695_IRQ_UART_RX, port); 375 free_irq(KS8695_IRQ_UART_TX, port); 376 free_irq(KS8695_IRQ_UART_MODEM_STATUS, port); 377 free_irq(KS8695_IRQ_UART_LINE_STATUS, port); 378 379 /* disable break condition and fifos */ 380 UART_PUT_LCR(port, UART_GET_LCR(port) & ~URLC_URSBC); 381 UART_PUT_FCR(port, UART_GET_FCR(port) & ~URFC_URFE); 382} 383 384static void ks8695uart_set_termios(struct uart_port *port, struct ktermios *termios, struct ktermios *old) 385{ 386 unsigned int lcr, fcr = 0; 387 unsigned long flags; 388 unsigned int baud, quot; 389 390 /* 391 * Ask the core to calculate the divisor for us. 392 */ 393 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16); 394 quot = uart_get_divisor(port, baud); 395 396 switch (termios->c_cflag & CSIZE) { 397 case CS5: 398 lcr = URCL_5; 399 break; 400 case CS6: 401 lcr = URCL_6; 402 break; 403 case CS7: 404 lcr = URCL_7; 405 break; 406 default: 407 lcr = URCL_8; 408 break; 409 } 410 411 /* stop bits */ 412 if (termios->c_cflag & CSTOPB) 413 lcr |= URLC_URSB; 414 415 /* parity */ 416 if (termios->c_cflag & PARENB) { 417 if (termios->c_cflag & CMSPAR) { /* Mark or Space parity */ 418 if (termios->c_cflag & PARODD) 419 lcr |= URPE_MARK; 420 else 421 lcr |= URPE_SPACE; 422 } 423 else if (termios->c_cflag & PARODD) 424 lcr |= URPE_ODD; 425 else 426 lcr |= URPE_EVEN; 427 } 428 429 if (port->fifosize > 1) 430 fcr = URFC_URFRT_8 | URFC_URTFR | URFC_URRFR | URFC_URFE; 431 432 spin_lock_irqsave(&port->lock, flags); 433 434 /* 435 * Update the per-port timeout. 436 */ 437 uart_update_timeout(port, termios->c_cflag, baud); 438 439 port->read_status_mask = URLS_URROE; 440 if (termios->c_iflag & INPCK) 441 port->read_status_mask |= (URLS_URFE | URLS_URPE); 442 if (termios->c_iflag & (BRKINT | PARMRK)) 443 port->read_status_mask |= URLS_URBI; 444 445 /* 446 * Characters to ignore 447 */ 448 port->ignore_status_mask = 0; 449 if (termios->c_iflag & IGNPAR) 450 port->ignore_status_mask |= (URLS_URFE | URLS_URPE); 451 if (termios->c_iflag & IGNBRK) { 452 port->ignore_status_mask |= URLS_URBI; 453 /* 454 * If we're ignoring parity and break indicators, 455 * ignore overruns too (for real raw support). 456 */ 457 if (termios->c_iflag & IGNPAR) 458 port->ignore_status_mask |= URLS_URROE; 459 } 460 461 /* 462 * Ignore all characters if CREAD is not set. 463 */ 464 if ((termios->c_cflag & CREAD) == 0) 465 port->ignore_status_mask |= UART_DUMMY_LSR_RX; 466 467 /* first, disable everything */ 468 if (UART_ENABLE_MS(port, termios->c_cflag)) 469 ks8695uart_enable_ms(port); 470 else 471 ks8695uart_disable_ms(port); 472 473 /* Set baud rate */ 474 UART_PUT_BRDR(port, quot); 475 476 UART_PUT_LCR(port, lcr); 477 UART_PUT_FCR(port, fcr); 478 479 spin_unlock_irqrestore(&port->lock, flags); 480} 481 482static const char *ks8695uart_type(struct uart_port *port) 483{ 484 return port->type == PORT_KS8695 ? "KS8695" : NULL; 485} 486 487/* 488 * Release the memory region(s) being used by 'port' 489 */ 490static void ks8695uart_release_port(struct uart_port *port) 491{ 492 release_mem_region(port->mapbase, UART_PORT_SIZE); 493} 494 495/* 496 * Request the memory region(s) being used by 'port' 497 */ 498static int ks8695uart_request_port(struct uart_port *port) 499{ 500 return request_mem_region(port->mapbase, UART_PORT_SIZE, 501 "serial_ks8695") != NULL ? 0 : -EBUSY; 502} 503 504/* 505 * Configure/autoconfigure the port. 506 */ 507static void ks8695uart_config_port(struct uart_port *port, int flags) 508{ 509 if (flags & UART_CONFIG_TYPE) { 510 port->type = PORT_KS8695; 511 ks8695uart_request_port(port); 512 } 513} 514 515/* 516 * verify the new serial_struct (for TIOCSSERIAL). 517 */ 518static int ks8695uart_verify_port(struct uart_port *port, struct serial_struct *ser) 519{ 520 int ret = 0; 521 522 if (ser->type != PORT_UNKNOWN && ser->type != PORT_KS8695) 523 ret = -EINVAL; 524 if (ser->irq != port->irq) 525 ret = -EINVAL; 526 if (ser->baud_base < 9600) 527 ret = -EINVAL; 528 return ret; 529} 530 531static struct uart_ops ks8695uart_pops = { 532 .tx_empty = ks8695uart_tx_empty, 533 .set_mctrl = ks8695uart_set_mctrl, 534 .get_mctrl = ks8695uart_get_mctrl, 535 .stop_tx = ks8695uart_stop_tx, 536 .start_tx = ks8695uart_start_tx, 537 .stop_rx = ks8695uart_stop_rx, 538 .enable_ms = ks8695uart_enable_ms, 539 .break_ctl = ks8695uart_break_ctl, 540 .startup = ks8695uart_startup, 541 .shutdown = ks8695uart_shutdown, 542 .set_termios = ks8695uart_set_termios, 543 .type = ks8695uart_type, 544 .release_port = ks8695uart_release_port, 545 .request_port = ks8695uart_request_port, 546 .config_port = ks8695uart_config_port, 547 .verify_port = ks8695uart_verify_port, 548}; 549 550static struct uart_port ks8695uart_ports[SERIAL_KS8695_NR] = { 551 { 552 .membase = (void *) KS8695_UART_VA, 553 .mapbase = KS8695_UART_VA, 554 .iotype = SERIAL_IO_MEM, 555 .irq = KS8695_IRQ_UART_TX, 556 .uartclk = KS8695_CLOCK_RATE * 16, 557 .fifosize = 16, 558 .ops = &ks8695uart_pops, 559 .flags = ASYNC_BOOT_AUTOCONF, 560 .line = 0, 561 } 562}; 563 564#ifdef CONFIG_SERIAL_KS8695_CONSOLE 565static void ks8695_console_putchar(struct uart_port *port, int ch) 566{ 567 while (!(UART_GET_LSR(port) & URLS_URTHRE)) 568 barrier(); 569 570 UART_PUT_CHAR(port, ch); 571} 572 573static void ks8695_console_write(struct console *co, const char *s, u_int count) 574{ 575 struct uart_port *port = ks8695uart_ports + co->index; 576 577 uart_console_write(port, s, count, ks8695_console_putchar); 578} 579 580static void __init ks8695_console_get_options(struct uart_port *port, int *baud, int *parity, int *bits) 581{ 582 unsigned int lcr; 583 584 lcr = UART_GET_LCR(port); 585 586 switch (lcr & URLC_PARITY) { 587 case URPE_ODD: 588 *parity = 'o'; 589 break; 590 case URPE_EVEN: 591 *parity = 'e'; 592 break; 593 default: 594 *parity = 'n'; 595 } 596 597 switch (lcr & URLC_URCL) { 598 case URCL_5: 599 *bits = 5; 600 break; 601 case URCL_6: 602 *bits = 6; 603 break; 604 case URCL_7: 605 *bits = 7; 606 break; 607 default: 608 *bits = 8; 609 } 610 611 *baud = port->uartclk / (UART_GET_BRDR(port) & 0x0FFF); 612 *baud /= 16; 613 *baud &= 0xFFFFFFF0; 614} 615 616static int __init ks8695_console_setup(struct console *co, char *options) 617{ 618 struct uart_port *port; 619 int baud = 115200; 620 int bits = 8; 621 int parity = 'n'; 622 int flow = 'n'; 623 624 /* 625 * Check whether an invalid uart number has been specified, and 626 * if so, search for the first available port that does have 627 * console support. 628 */ 629 port = uart_get_console(ks8695uart_ports, SERIAL_KS8695_NR, co); 630 631 if (options) 632 uart_parse_options(options, &baud, &parity, &bits, &flow); 633 else 634 ks8695_console_get_options(port, &baud, &parity, &bits); 635 636 return uart_set_options(port, co, baud, parity, bits, flow); 637} 638 639static struct uart_driver ks8695_reg; 640 641static struct console ks8695_console = { 642 .name = SERIAL_KS8695_DEVNAME, 643 .write = ks8695_console_write, 644 .device = uart_console_device, 645 .setup = ks8695_console_setup, 646 .flags = CON_PRINTBUFFER, 647 .index = -1, 648 .data = &ks8695_reg, 649}; 650 651static int __init ks8695_console_init(void) 652{ 653 add_preferred_console(SERIAL_KS8695_DEVNAME, 0, NULL); 654 register_console(&ks8695_console); 655 return 0; 656} 657 658console_initcall(ks8695_console_init); 659 660#define KS8695_CONSOLE &ks8695_console 661#else 662#define KS8695_CONSOLE NULL 663#endif 664 665static struct uart_driver ks8695_reg = { 666 .owner = THIS_MODULE, 667 .driver_name = "serial_ks8695", 668 .dev_name = SERIAL_KS8695_DEVNAME, 669 .major = SERIAL_KS8695_MAJOR, 670 .minor = SERIAL_KS8695_MINOR, 671 .nr = SERIAL_KS8695_NR, 672 .cons = KS8695_CONSOLE, 673}; 674 675static int __init ks8695uart_init(void) 676{ 677 int i, ret; 678 679 printk(KERN_INFO "Serial: Micrel KS8695 UART driver\n"); 680 681 ret = uart_register_driver(&ks8695_reg); 682 if (ret) 683 return ret; 684 685 for (i = 0; i < SERIAL_KS8695_NR; i++) 686 uart_add_one_port(&ks8695_reg, &ks8695uart_ports[0]); 687 688 return 0; 689} 690 691static void __exit ks8695uart_exit(void) 692{ 693 int i; 694 695 for (i = 0; i < SERIAL_KS8695_NR; i++) 696 uart_remove_one_port(&ks8695_reg, &ks8695uart_ports[0]); 697 uart_unregister_driver(&ks8695_reg); 698} 699 700module_init(ks8695uart_init); 701module_exit(ks8695uart_exit); 702 703MODULE_DESCRIPTION("KS8695 serial port driver"); 704MODULE_AUTHOR("Micrel Inc."); 705MODULE_LICENSE("GPL"); 706