drivers/serial/serial_ks8695.c

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