drivers/tty/serial/clps711x.c

   1 /*
   2  *  Driver for CLPS711x serial ports
   3  *
   4  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
   5  *
   6  *  Copyright 1999 ARM Limited
   7  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  */
  23
  24 #if defined(CONFIG_SERIAL_CLPS711X_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  25 #define SUPPORT_SYSRQ
  26 #endif
  27
  28 #include <linux/module.h>
  29 #include <linux/ioport.h>
  30 #include <linux/init.h>
  31 #include <linux/console.h>
  32 #include <linux/sysrq.h>
  33 #include <linux/spinlock.h>
  34 #include <linux/device.h>
  35 #include <linux/tty.h>
  36 #include <linux/tty_flip.h>
  37 #include <linux/serial_core.h>
  38 #include <linux/serial.h>
  39 #include <linux/io.h>
  40
  41 #include <mach/hardware.h>
  42 #include <asm/irq.h>
  43
  44 #define UART_NR         2
  45
  46 #define SERIAL_CLPS711X_MAJOR   204
  47 #define SERIAL_CLPS711X_MINOR   40
  48 #define SERIAL_CLPS711X_NR      UART_NR
  49
  50 /*
  51  * We use the relevant SYSCON register as a base address for these ports.
  52  */
  53 #define UBRLCR(port)            ((port)->iobase + UBRLCR1 - SYSCON1)
  54 #define UARTDR(port)            ((port)->iobase + UARTDR1 - SYSCON1)
  55 #define SYSFLG(port)            ((port)->iobase + SYSFLG1 - SYSCON1)
  56 #define SYSCON(port)            ((port)->iobase + SYSCON1 - SYSCON1)
  57
  58 #define TX_IRQ(port)            ((port)->irq)
  59 #define RX_IRQ(port)            ((port)->irq + 1)
  60
  61 #define UART_ANY_ERR            (UARTDR_FRMERR | UARTDR_PARERR | UARTDR_OVERR)
  62
  63 #define tx_enabled(port)        ((port)->unused[0])
  64
  65 static void clps711xuart_stop_tx(struct uart_port *port)
  66 {
  67         if (tx_enabled(port)) {
  68                 disable_irq(TX_IRQ(port));
  69                 tx_enabled(port) = 0;
  70         }
  71 }
  72
  73 static void clps711xuart_start_tx(struct uart_port *port)
  74 {
  75         if (!tx_enabled(port)) {
  76                 enable_irq(TX_IRQ(port));
  77                 tx_enabled(port) = 1;
  78         }
  79 }
  80
  81 static void clps711xuart_stop_rx(struct uart_port *port)
  82 {
  83         disable_irq(RX_IRQ(port));
  84 }
  85
  86 static void clps711xuart_enable_ms(struct uart_port *port)
  87 {
  88 }
  89
  90 static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id)
  91 {
  92         struct uart_port *port = dev_id;
  93         struct tty_struct *tty = port->state->port.tty;
  94         unsigned int status, ch, flg;
  95
  96         status = clps_readl(SYSFLG(port));
  97         while (!(status & SYSFLG_URXFE)) {
  98                 ch = clps_readl(UARTDR(port));
  99
 100                 port->icount.rx++;
 101
 102                 flg = TTY_NORMAL;
 103
 104                 /*
 105                  * Note that the error handling code is
 106                  * out of the main execution path
 107                  */
 108                 if (unlikely(ch & UART_ANY_ERR)) {
 109                         if (ch & UARTDR_PARERR)
 110                                 port->icount.parity++;
 111                         else if (ch & UARTDR_FRMERR)
 112                                 port->icount.frame++;
 113                         if (ch & UARTDR_OVERR)
 114                                 port->icount.overrun++;
 115
 116                         ch &= port->read_status_mask;
 117
 118                         if (ch & UARTDR_PARERR)
 119                                 flg = TTY_PARITY;
 120                         else if (ch & UARTDR_FRMERR)
 121                                 flg = TTY_FRAME;
 122
 123 #ifdef SUPPORT_SYSRQ
 124                         port->sysrq = 0;
 125 #endif
 126                 }
 127
 128                 if (uart_handle_sysrq_char(port, ch))
 129                         goto ignore_char;
 130
 131                 /*
 132                  * CHECK: does overrun affect the current character?
 133                  * ASSUMPTION: it does not.
 134                  */
 135                 uart_insert_char(port, ch, UARTDR_OVERR, ch, flg);
 136
 137         ignore_char:
 138                 status = clps_readl(SYSFLG(port));
 139         }
 140         tty_flip_buffer_push(tty);
 141         return IRQ_HANDLED;
 142 }
 143
 144 static irqreturn_t clps711xuart_int_tx(int irq, void *dev_id)
 145 {
 146         struct uart_port *port = dev_id;
 147         struct circ_buf *xmit = &port->state->xmit;
 148         int count;
 149
 150         if (port->x_char) {
 151                 clps_writel(port->x_char, UARTDR(port));
 152                 port->icount.tx++;
 153                 port->x_char = 0;
 154                 return IRQ_HANDLED;
 155         }
 156
 157         if (uart_circ_empty(xmit) || uart_tx_stopped(port))
 158                 goto disable_tx_irq;
 159
 160         count = port->fifosize >> 1;
 161         do {
 162                 clps_writel(xmit->buf[xmit->tail], UARTDR(port));
 163                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 164                 port->icount.tx++;
 165                 if (uart_circ_empty(xmit))
 166                         break;
 167         } while (--count > 0);
 168
 169         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 170                 uart_write_wakeup(port);
 171
 172         if (uart_circ_empty(xmit)) {
 173         disable_tx_irq:
 174                 disable_irq_nosync(TX_IRQ(port));
 175                 tx_enabled(port) = 0;
 176         }
 177
 178         return IRQ_HANDLED;
 179 }
 180
 181 static unsigned int clps711xuart_tx_empty(struct uart_port *port)
 182 {
 183         unsigned int status = clps_readl(SYSFLG(port));
 184         return status & SYSFLG_UBUSY ? 0 : TIOCSER_TEMT;
 185 }
 186
 187 static unsigned int clps711xuart_get_mctrl(struct uart_port *port)
 188 {
 189         unsigned int port_addr;
 190         unsigned int result = 0;
 191         unsigned int status;
 192
 193         port_addr = SYSFLG(port);
 194         if (port_addr == SYSFLG1) {
 195                 status = clps_readl(SYSFLG1);
 196                 if (status & SYSFLG1_DCD)
 197                         result |= TIOCM_CAR;
 198                 if (status & SYSFLG1_DSR)
 199                         result |= TIOCM_DSR;
 200                 if (status & SYSFLG1_CTS)
 201                         result |= TIOCM_CTS;
 202         }
 203
 204         return result;
 205 }
 206
 207 static void
 208 clps711xuart_set_mctrl_null(struct uart_port *port, unsigned int mctrl)
 209 {
 210 }
 211
 212 static void clps711xuart_break_ctl(struct uart_port *port, int break_state)
 213 {
 214         unsigned long flags;
 215         unsigned int ubrlcr;
 216
 217         spin_lock_irqsave(&port->lock, flags);
 218         ubrlcr = clps_readl(UBRLCR(port));
 219         if (break_state == -1)
 220                 ubrlcr |= UBRLCR_BREAK;
 221         else
 222                 ubrlcr &= ~UBRLCR_BREAK;
 223         clps_writel(ubrlcr, UBRLCR(port));
 224         spin_unlock_irqrestore(&port->lock, flags);
 225 }
 226
 227 static int clps711xuart_startup(struct uart_port *port)
 228 {
 229         unsigned int syscon;
 230         int retval;
 231
 232         tx_enabled(port) = 1;
 233
 234         /*
 235          * Allocate the IRQs
 236          */
 237         retval = request_irq(TX_IRQ(port), clps711xuart_int_tx, 0,
 238                              "clps711xuart_tx", port);
 239         if (retval)
 240                 return retval;
 241
 242         retval = request_irq(RX_IRQ(port), clps711xuart_int_rx, 0,
 243                              "clps711xuart_rx", port);
 244         if (retval) {
 245                 free_irq(TX_IRQ(port), port);
 246                 return retval;
 247         }
 248
 249         /*
 250          * enable the port
 251          */
 252         syscon = clps_readl(SYSCON(port));
 253         syscon |= SYSCON_UARTEN;
 254         clps_writel(syscon, SYSCON(port));
 255
 256         return 0;
 257 }
 258
 259 static void clps711xuart_shutdown(struct uart_port *port)
 260 {
 261         unsigned int ubrlcr, syscon;
 262
 263         /*
 264          * Free the interrupt
 265          */
 266         free_irq(TX_IRQ(port), port);   /* TX interrupt */
 267         free_irq(RX_IRQ(port), port);   /* RX interrupt */
 268
 269         /*
 270          * disable the port
 271          */
 272         syscon = clps_readl(SYSCON(port));
 273         syscon &= ~SYSCON_UARTEN;
 274         clps_writel(syscon, SYSCON(port));
 275
 276         /*
 277          * disable break condition and fifos
 278          */
 279         ubrlcr = clps_readl(UBRLCR(port));
 280         ubrlcr &= ~(UBRLCR_FIFOEN | UBRLCR_BREAK);
 281         clps_writel(ubrlcr, UBRLCR(port));
 282 }
 283
 284 static void
 285 clps711xuart_set_termios(struct uart_port *port, struct ktermios *termios,
 286                          struct ktermios *old)
 287 {
 288         unsigned int ubrlcr, baud, quot;
 289         unsigned long flags;
 290
 291         /*
 292          * We don't implement CREAD.
 293          */
 294         termios->c_cflag |= CREAD;
 295
 296         /*
 297          * Ask the core to calculate the divisor for us.
 298          */
 299         baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk/16);
 300         quot = uart_get_divisor(port, baud);
 301
 302         switch (termios->c_cflag & CSIZE) {
 303         case CS5:
 304                 ubrlcr = UBRLCR_WRDLEN5;
 305                 break;
 306         case CS6:
 307                 ubrlcr = UBRLCR_WRDLEN6;
 308                 break;
 309         case CS7:
 310                 ubrlcr = UBRLCR_WRDLEN7;
 311                 break;
 312         default: // CS8
 313                 ubrlcr = UBRLCR_WRDLEN8;
 314                 break;
 315         }
 316         if (termios->c_cflag & CSTOPB)
 317                 ubrlcr |= UBRLCR_XSTOP;
 318         if (termios->c_cflag & PARENB) {
 319                 ubrlcr |= UBRLCR_PRTEN;
 320                 if (!(termios->c_cflag & PARODD))
 321                         ubrlcr |= UBRLCR_EVENPRT;
 322         }
 323         if (port->fifosize > 1)
 324                 ubrlcr |= UBRLCR_FIFOEN;
 325
 326         spin_lock_irqsave(&port->lock, flags);
 327
 328         /*
 329          * Update the per-port timeout.
 330          */
 331         uart_update_timeout(port, termios->c_cflag, baud);
 332
 333         port->read_status_mask = UARTDR_OVERR;
 334         if (termios->c_iflag & INPCK)
 335                 port->read_status_mask |= UARTDR_PARERR | UARTDR_FRMERR;
 336
 337         /*
 338          * Characters to ignore
 339          */
 340         port->ignore_status_mask = 0;
 341         if (termios->c_iflag & IGNPAR)
 342                 port->ignore_status_mask |= UARTDR_FRMERR | UARTDR_PARERR;
 343         if (termios->c_iflag & IGNBRK) {
 344                 /*
 345                  * If we're ignoring parity and break indicators,
 346                  * ignore overruns to (for real raw support).
 347                  */
 348                 if (termios->c_iflag & IGNPAR)
 349                         port->ignore_status_mask |= UARTDR_OVERR;
 350         }
 351
 352         quot -= 1;
 353
 354         clps_writel(ubrlcr | quot, UBRLCR(port));
 355
 356         spin_unlock_irqrestore(&port->lock, flags);
 357 }
 358
 359 static const char *clps711xuart_type(struct uart_port *port)
 360 {
 361         return port->type == PORT_CLPS711X ? "CLPS711x" : NULL;
 362 }
 363
 364 /*
 365  * Configure/autoconfigure the port.
 366  */
 367 static void clps711xuart_config_port(struct uart_port *port, int flags)
 368 {
 369         if (flags & UART_CONFIG_TYPE)
 370                 port->type = PORT_CLPS711X;
 371 }
 372
 373 static void clps711xuart_release_port(struct uart_port *port)
 374 {
 375 }
 376
 377 static int clps711xuart_request_port(struct uart_port *port)
 378 {
 379         return 0;
 380 }
 381
 382 static struct uart_ops clps711x_pops = {
 383         .tx_empty       = clps711xuart_tx_empty,
 384         .set_mctrl      = clps711xuart_set_mctrl_null,
 385         .get_mctrl      = clps711xuart_get_mctrl,
 386         .stop_tx        = clps711xuart_stop_tx,
 387         .start_tx       = clps711xuart_start_tx,
 388         .stop_rx        = clps711xuart_stop_rx,
 389         .enable_ms      = clps711xuart_enable_ms,
 390         .break_ctl      = clps711xuart_break_ctl,
 391         .startup        = clps711xuart_startup,
 392         .shutdown       = clps711xuart_shutdown,
 393         .set_termios    = clps711xuart_set_termios,
 394         .type           = clps711xuart_type,
 395         .config_port    = clps711xuart_config_port,
 396         .release_port   = clps711xuart_release_port,
 397         .request_port   = clps711xuart_request_port,
 398 };
 399
 400 static struct uart_port clps711x_ports[UART_NR] = {
 401         {
 402                 .iobase         = SYSCON1,
 403                 .irq            = IRQ_UTXINT1, /* IRQ_URXINT1, IRQ_UMSINT */
 404                 .uartclk        = 3686400,
 405                 .fifosize       = 16,
 406                 .ops            = &clps711x_pops,
 407                 .line           = 0,
 408                 .flags          = UPF_BOOT_AUTOCONF,
 409         },
 410         {
 411                 .iobase         = SYSCON2,
 412                 .irq            = IRQ_UTXINT2, /* IRQ_URXINT2 */
 413                 .uartclk        = 3686400,
 414                 .fifosize       = 16,
 415                 .ops            = &clps711x_pops,
 416                 .line           = 1,
 417                 .flags          = UPF_BOOT_AUTOCONF,
 418         }
 419 };
 420
 421 #ifdef CONFIG_SERIAL_CLPS711X_CONSOLE
 422 static void clps711xuart_console_putchar(struct uart_port *port, int ch)
 423 {
 424         while (clps_readl(SYSFLG(port)) & SYSFLG_UTXFF)
 425                 barrier();
 426         clps_writel(ch, UARTDR(port));
 427 }
 428
 429 /*
 430  *      Print a string to the serial port trying not to disturb
 431  *      any possible real use of the port...
 432  *
 433  *      The console_lock must be held when we get here.
 434  *
 435  *      Note that this is called with interrupts already disabled
 436  */
 437 static void
 438 clps711xuart_console_write(struct console *co, const char *s,
 439                            unsigned int count)
 440 {
 441         struct uart_port *port = clps711x_ports + co->index;
 442         unsigned int status, syscon;
 443
 444         /*
 445          *      Ensure that the port is enabled.
 446          */
 447         syscon = clps_readl(SYSCON(port));
 448         clps_writel(syscon | SYSCON_UARTEN, SYSCON(port));
 449
 450         uart_console_write(port, s, count, clps711xuart_console_putchar);
 451
 452         /*
 453          *      Finally, wait for transmitter to become empty
 454          *      and restore the uart state.
 455          */
 456         do {
 457                 status = clps_readl(SYSFLG(port));
 458         } while (status & SYSFLG_UBUSY);
 459
 460         clps_writel(syscon, SYSCON(port));
 461 }
 462
 463 static void __init
 464 clps711xuart_console_get_options(struct uart_port *port, int *baud,
 465                                  int *parity, int *bits)
 466 {
 467         if (clps_readl(SYSCON(port)) & SYSCON_UARTEN) {
 468                 unsigned int ubrlcr, quot;
 469
 470                 ubrlcr = clps_readl(UBRLCR(port));
 471
 472                 *parity = 'n';
 473                 if (ubrlcr & UBRLCR_PRTEN) {
 474                         if (ubrlcr & UBRLCR_EVENPRT)
 475                                 *parity = 'e';
 476                         else
 477                                 *parity = 'o';
 478                 }
 479
 480                 if ((ubrlcr & UBRLCR_WRDLEN_MASK) == UBRLCR_WRDLEN7)
 481                         *bits = 7;
 482                 else
 483                         *bits = 8;
 484
 485                 quot = ubrlcr & UBRLCR_BAUD_MASK;
 486                 *baud = port->uartclk / (16 * (quot + 1));
 487         }
 488 }
 489
 490 static int __init clps711xuart_console_setup(struct console *co, char *options)
 491 {
 492         struct uart_port *port;
 493         int baud = 38400;
 494         int bits = 8;
 495         int parity = 'n';
 496         int flow = 'n';
 497
 498         /*
 499          * Check whether an invalid uart number has been specified, and
 500          * if so, search for the first available port that does have
 501          * console support.
 502          */
 503         port = uart_get_console(clps711x_ports, UART_NR, co);
 504
 505         if (options)
 506                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 507         else
 508                 clps711xuart_console_get_options(port, &baud, &parity, &bits);
 509
 510         return uart_set_options(port, co, baud, parity, bits, flow);
 511 }
 512
 513 static struct uart_driver clps711x_reg;
 514 static struct console clps711x_console = {
 515         .name           = "ttyCL",
 516         .write          = clps711xuart_console_write,
 517         .device         = uart_console_device,
 518         .setup          = clps711xuart_console_setup,
 519         .flags          = CON_PRINTBUFFER,
 520         .index          = -1,
 521         .data           = &clps711x_reg,
 522 };
 523
 524 static int __init clps711xuart_console_init(void)
 525 {
 526         register_console(&clps711x_console);
 527         return 0;
 528 }
 529 console_initcall(clps711xuart_console_init);
 530
 531 #define CLPS711X_CONSOLE        &clps711x_console
 532 #else
 533 #define CLPS711X_CONSOLE        NULL
 534 #endif
 535
 536 static struct uart_driver clps711x_reg = {
 537         .driver_name            = "ttyCL",
 538         .dev_name               = "ttyCL",
 539         .major                  = SERIAL_CLPS711X_MAJOR,
 540         .minor                  = SERIAL_CLPS711X_MINOR,
 541         .nr                     = UART_NR,
 542
 543         .cons                   = CLPS711X_CONSOLE,
 544 };
 545
 546 static int __init clps711xuart_init(void)
 547 {
 548         int ret, i;
 549
 550         printk(KERN_INFO "Serial: CLPS711x driver\n");
 551
 552         ret = uart_register_driver(&clps711x_reg);
 553         if (ret)
 554                 return ret;
 555
 556         for (i = 0; i < UART_NR; i++)
 557                 uart_add_one_port(&clps711x_reg, &clps711x_ports[i]);
 558
 559         return 0;
 560 }
 561
 562 static void __exit clps711xuart_exit(void)
 563 {
 564         int i;
 565
 566         for (i = 0; i < UART_NR; i++)
 567                 uart_remove_one_port(&clps711x_reg, &clps711x_ports[i]);
 568
 569         uart_unregister_driver(&clps711x_reg);
 570 }
 571
 572 module_init(clps711xuart_init);
 573 module_exit(clps711xuart_exit);
 574
 575 MODULE_AUTHOR("Deep Blue Solutions Ltd");
 576 MODULE_DESCRIPTION("CLPS-711x generic serial driver");
 577 MODULE_LICENSE("GPL");
 578 MODULE_ALIAS_CHARDEV(SERIAL_CLPS711X_MAJOR, SERIAL_CLPS711X_MINOR);