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 #include <linux/clk.h>
  41 #include <linux/platform_device.h>
  42
  43 #include <mach/hardware.h>
  44 #include <asm/irq.h>
  45
  46 #define UART_CLPS711X_NAME      "uart-clps711x"
  47 #define UART_CLPS711X_NR        2
  48 #define UART_CLPS711X_MAJOR     204
  49 #define UART_CLPS711X_MINOR     40
  50
  51 #define UBRLCR(port)            ((port)->line ? UBRLCR2 : UBRLCR1)
  52 #define UARTDR(port)            ((port)->line ? UARTDR2 : UARTDR1)
  53 #define SYSFLG(port)            ((port)->line ? SYSFLG2 : SYSFLG1)
  54 #define SYSCON(port)            ((port)->line ? SYSCON2 : SYSCON1)
  55 #define TX_IRQ(port)            ((port)->line ? IRQ_UTXINT2 : IRQ_UTXINT1)
  56 #define RX_IRQ(port)            ((port)->line ? IRQ_URXINT2 : IRQ_URXINT1)
  57
  58 #define UART_ANY_ERR            (UARTDR_FRMERR | UARTDR_PARERR | UARTDR_OVERR)
  59
  60 struct clps711x_port {
  61         struct uart_driver      uart;
  62         struct clk              *uart_clk;
  63         struct uart_port        port[UART_CLPS711X_NR];
  64         int                     tx_enabled[UART_CLPS711X_NR];
  65 #ifdef CONFIG_SERIAL_CLPS711X_CONSOLE
  66         struct console          console;
  67 #endif
  68 };
  69
  70 static void clps711xuart_stop_tx(struct uart_port *port)
  71 {
  72         struct clps711x_port *s = dev_get_drvdata(port->dev);
  73
  74         if (s->tx_enabled[port->line]) {
  75                 disable_irq(TX_IRQ(port));
  76                 s->tx_enabled[port->line] = 0;
  77         }
  78 }
  79
  80 static void clps711xuart_start_tx(struct uart_port *port)
  81 {
  82         struct clps711x_port *s = dev_get_drvdata(port->dev);
  83
  84         if (!s->tx_enabled[port->line]) {
  85                 enable_irq(TX_IRQ(port));
  86                 s->tx_enabled[port->line] = 1;
  87         }
  88 }
  89
  90 static void clps711xuart_stop_rx(struct uart_port *port)
  91 {
  92         disable_irq(RX_IRQ(port));
  93 }
  94
  95 static void clps711xuart_enable_ms(struct uart_port *port)
  96 {
  97 }
  98
  99 static irqreturn_t clps711xuart_int_rx(int irq, void *dev_id)
 100 {
 101         struct uart_port *port = dev_id;
 102         struct tty_struct *tty = port->state->port.tty;
 103         unsigned int status, ch, flg;
 104
 105         status = clps_readl(SYSFLG(port));
 106         while (!(status & SYSFLG_URXFE)) {
 107                 ch = clps_readl(UARTDR(port));
 108
 109                 port->icount.rx++;
 110
 111                 flg = TTY_NORMAL;
 112
 113                 /*
 114                  * Note that the error handling code is
 115                  * out of the main execution path
 116                  */
 117                 if (unlikely(ch & UART_ANY_ERR)) {
 118                         if (ch & UARTDR_PARERR)
 119                                 port->icount.parity++;
 120                         else if (ch & UARTDR_FRMERR)
 121                                 port->icount.frame++;
 122                         if (ch & UARTDR_OVERR)
 123                                 port->icount.overrun++;
 124
 125                         ch &= port->read_status_mask;
 126
 127                         if (ch & UARTDR_PARERR)
 128                                 flg = TTY_PARITY;
 129                         else if (ch & UARTDR_FRMERR)
 130                                 flg = TTY_FRAME;
 131
 132 #ifdef SUPPORT_SYSRQ
 133                         port->sysrq = 0;
 134 #endif
 135                 }
 136
 137                 if (uart_handle_sysrq_char(port, ch))
 138                         goto ignore_char;
 139
 140                 /*
 141                  * CHECK: does overrun affect the current character?
 142                  * ASSUMPTION: it does not.
 143                  */
 144                 uart_insert_char(port, ch, UARTDR_OVERR, ch, flg);
 145
 146         ignore_char:
 147                 status = clps_readl(SYSFLG(port));
 148         }
 149         tty_flip_buffer_push(tty);
 150         return IRQ_HANDLED;
 151 }
 152
 153 static irqreturn_t clps711xuart_int_tx(int irq, void *dev_id)
 154 {
 155         struct uart_port *port = dev_id;
 156         struct clps711x_port *s = dev_get_drvdata(port->dev);
 157         struct circ_buf *xmit = &port->state->xmit;
 158         int count;
 159
 160         if (port->x_char) {
 161                 clps_writel(port->x_char, UARTDR(port));
 162                 port->icount.tx++;
 163                 port->x_char = 0;
 164                 return IRQ_HANDLED;
 165         }
 166
 167         if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
 168                 disable_irq_nosync(TX_IRQ(port));
 169                 s->tx_enabled[port->line] = 0;
 170                 return IRQ_HANDLED;
 171         }
 172
 173         count = port->fifosize >> 1;
 174         do {
 175                 clps_writel(xmit->buf[xmit->tail], UARTDR(port));
 176                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 177                 port->icount.tx++;
 178                 if (uart_circ_empty(xmit))
 179                         break;
 180         } while (--count > 0);
 181
 182         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 183                 uart_write_wakeup(port);
 184
 185         return IRQ_HANDLED;
 186 }
 187
 188 static unsigned int clps711xuart_tx_empty(struct uart_port *port)
 189 {
 190         unsigned int status = clps_readl(SYSFLG(port));
 191         return status & SYSFLG_UBUSY ? 0 : TIOCSER_TEMT;
 192 }
 193
 194 static unsigned int clps711xuart_get_mctrl(struct uart_port *port)
 195 {
 196         unsigned int port_addr;
 197         unsigned int result = 0;
 198         unsigned int status;
 199
 200         port_addr = SYSFLG(port);
 201         if (port_addr == SYSFLG1) {
 202                 status = clps_readl(SYSFLG1);
 203                 if (status & SYSFLG1_DCD)
 204                         result |= TIOCM_CAR;
 205                 if (status & SYSFLG1_DSR)
 206                         result |= TIOCM_DSR;
 207                 if (status & SYSFLG1_CTS)
 208                         result |= TIOCM_CTS;
 209         }
 210
 211         return result;
 212 }
 213
 214 static void
 215 clps711xuart_set_mctrl_null(struct uart_port *port, unsigned int mctrl)
 216 {
 217 }
 218
 219 static void clps711xuart_break_ctl(struct uart_port *port, int break_state)
 220 {
 221         unsigned long flags;
 222         unsigned int ubrlcr;
 223
 224         spin_lock_irqsave(&port->lock, flags);
 225         ubrlcr = clps_readl(UBRLCR(port));
 226         if (break_state == -1)
 227                 ubrlcr |= UBRLCR_BREAK;
 228         else
 229                 ubrlcr &= ~UBRLCR_BREAK;
 230         clps_writel(ubrlcr, UBRLCR(port));
 231         spin_unlock_irqrestore(&port->lock, flags);
 232 }
 233
 234 static int clps711xuart_startup(struct uart_port *port)
 235 {
 236         struct clps711x_port *s = dev_get_drvdata(port->dev);
 237         unsigned int syscon;
 238         int retval;
 239
 240         s->tx_enabled[port->line] = 1;
 241
 242         /*
 243          * Allocate the IRQs
 244          */
 245         retval = request_irq(TX_IRQ(port), clps711xuart_int_tx, 0,
 246                              "clps711xuart_tx", port);
 247         if (retval)
 248                 return retval;
 249
 250         retval = request_irq(RX_IRQ(port), clps711xuart_int_rx, 0,
 251                              "clps711xuart_rx", port);
 252         if (retval) {
 253                 free_irq(TX_IRQ(port), port);
 254                 return retval;
 255         }
 256
 257         /*
 258          * enable the port
 259          */
 260         syscon = clps_readl(SYSCON(port));
 261         syscon |= SYSCON_UARTEN;
 262         clps_writel(syscon, SYSCON(port));
 263
 264         return 0;
 265 }
 266
 267 static void clps711xuart_shutdown(struct uart_port *port)
 268 {
 269         unsigned int ubrlcr, syscon;
 270
 271         /*
 272          * Free the interrupt
 273          */
 274         free_irq(TX_IRQ(port), port);   /* TX interrupt */
 275         free_irq(RX_IRQ(port), port);   /* RX interrupt */
 276
 277         /*
 278          * disable the port
 279          */
 280         syscon = clps_readl(SYSCON(port));
 281         syscon &= ~SYSCON_UARTEN;
 282         clps_writel(syscon, SYSCON(port));
 283
 284         /*
 285          * disable break condition and fifos
 286          */
 287         ubrlcr = clps_readl(UBRLCR(port));
 288         ubrlcr &= ~(UBRLCR_FIFOEN | UBRLCR_BREAK);
 289         clps_writel(ubrlcr, UBRLCR(port));
 290 }
 291
 292 static void
 293 clps711xuart_set_termios(struct uart_port *port, struct ktermios *termios,
 294                          struct ktermios *old)
 295 {
 296         unsigned int ubrlcr, baud, quot;
 297         unsigned long flags;
 298
 299         /*
 300          * We don't implement CREAD.
 301          */
 302         termios->c_cflag |= CREAD;
 303
 304         /* Ask the core to calculate the divisor for us */
 305         baud = uart_get_baud_rate(port, termios, old, port->uartclk / 4096,
 306                                                       port->uartclk / 16);
 307         quot = uart_get_divisor(port, baud);
 308
 309         switch (termios->c_cflag & CSIZE) {
 310         case CS5:
 311                 ubrlcr = UBRLCR_WRDLEN5;
 312                 break;
 313         case CS6:
 314                 ubrlcr = UBRLCR_WRDLEN6;
 315                 break;
 316         case CS7:
 317                 ubrlcr = UBRLCR_WRDLEN7;
 318                 break;
 319         default: // CS8
 320                 ubrlcr = UBRLCR_WRDLEN8;
 321                 break;
 322         }
 323         if (termios->c_cflag & CSTOPB)
 324                 ubrlcr |= UBRLCR_XSTOP;
 325         if (termios->c_cflag & PARENB) {
 326                 ubrlcr |= UBRLCR_PRTEN;
 327                 if (!(termios->c_cflag & PARODD))
 328                         ubrlcr |= UBRLCR_EVENPRT;
 329         }
 330         if (port->fifosize > 1)
 331                 ubrlcr |= UBRLCR_FIFOEN;
 332
 333         spin_lock_irqsave(&port->lock, flags);
 334
 335         /*
 336          * Update the per-port timeout.
 337          */
 338         uart_update_timeout(port, termios->c_cflag, baud);
 339
 340         port->read_status_mask = UARTDR_OVERR;
 341         if (termios->c_iflag & INPCK)
 342                 port->read_status_mask |= UARTDR_PARERR | UARTDR_FRMERR;
 343
 344         /*
 345          * Characters to ignore
 346          */
 347         port->ignore_status_mask = 0;
 348         if (termios->c_iflag & IGNPAR)
 349                 port->ignore_status_mask |= UARTDR_FRMERR | UARTDR_PARERR;
 350         if (termios->c_iflag & IGNBRK) {
 351                 /*
 352                  * If we're ignoring parity and break indicators,
 353                  * ignore overruns to (for real raw support).
 354                  */
 355                 if (termios->c_iflag & IGNPAR)
 356                         port->ignore_status_mask |= UARTDR_OVERR;
 357         }
 358
 359         quot -= 1;
 360
 361         clps_writel(ubrlcr | quot, UBRLCR(port));
 362
 363         spin_unlock_irqrestore(&port->lock, flags);
 364 }
 365
 366 static const char *clps711xuart_type(struct uart_port *port)
 367 {
 368         return port->type == PORT_CLPS711X ? "CLPS711x" : NULL;
 369 }
 370
 371 /*
 372  * Configure/autoconfigure the port.
 373  */
 374 static void clps711xuart_config_port(struct uart_port *port, int flags)
 375 {
 376         if (flags & UART_CONFIG_TYPE)
 377                 port->type = PORT_CLPS711X;
 378 }
 379
 380 static void clps711xuart_release_port(struct uart_port *port)
 381 {
 382 }
 383
 384 static int clps711xuart_request_port(struct uart_port *port)
 385 {
 386         return 0;
 387 }
 388
 389 static struct uart_ops uart_clps711x_ops = {
 390         .tx_empty       = clps711xuart_tx_empty,
 391         .set_mctrl      = clps711xuart_set_mctrl_null,
 392         .get_mctrl      = clps711xuart_get_mctrl,
 393         .stop_tx        = clps711xuart_stop_tx,
 394         .start_tx       = clps711xuart_start_tx,
 395         .stop_rx        = clps711xuart_stop_rx,
 396         .enable_ms      = clps711xuart_enable_ms,
 397         .break_ctl      = clps711xuart_break_ctl,
 398         .startup        = clps711xuart_startup,
 399         .shutdown       = clps711xuart_shutdown,
 400         .set_termios    = clps711xuart_set_termios,
 401         .type           = clps711xuart_type,
 402         .config_port    = clps711xuart_config_port,
 403         .release_port   = clps711xuart_release_port,
 404         .request_port   = clps711xuart_request_port,
 405 };
 406
 407 #ifdef CONFIG_SERIAL_CLPS711X_CONSOLE
 408 static void uart_clps711x_console_putchar(struct uart_port *port, int ch)
 409 {
 410         while (clps_readl(SYSFLG(port)) & SYSFLG_UTXFF)
 411                 barrier();
 412
 413         clps_writew(ch, UARTDR(port));
 414 }
 415
 416 static void uart_clps711x_console_write(struct console *co, const char *c,
 417                                         unsigned n)
 418 {
 419         struct clps711x_port *s = (struct clps711x_port *)co->data;
 420         struct uart_port *port = &s->port[co->index];
 421         u32 syscon;
 422
 423         /* Ensure that the port is enabled */
 424         syscon = clps_readl(SYSCON(port));
 425         clps_writel(syscon | SYSCON_UARTEN, SYSCON(port));
 426
 427         uart_console_write(port, c, n, uart_clps711x_console_putchar);
 428
 429         /* Wait for transmitter to become empty */
 430         while (clps_readl(SYSFLG(port)) & SYSFLG_UBUSY)
 431                 barrier();
 432
 433         /* Restore the uart state */
 434         clps_writel(syscon, SYSCON(port));
 435 }
 436
 437 static void uart_clps711x_console_get_options(struct uart_port *port,
 438                                               int *baud, int *parity,
 439                                               int *bits)
 440 {
 441         if (clps_readl(SYSCON(port)) & SYSCON_UARTEN) {
 442                 unsigned int ubrlcr, quot;
 443
 444                 ubrlcr = clps_readl(UBRLCR(port));
 445
 446                 *parity = 'n';
 447                 if (ubrlcr & UBRLCR_PRTEN) {
 448                         if (ubrlcr & UBRLCR_EVENPRT)
 449                                 *parity = 'e';
 450                         else
 451                                 *parity = 'o';
 452                 }
 453
 454                 if ((ubrlcr & UBRLCR_WRDLEN_MASK) == UBRLCR_WRDLEN7)
 455                         *bits = 7;
 456                 else
 457                         *bits = 8;
 458
 459                 quot = ubrlcr & UBRLCR_BAUD_MASK;
 460                 *baud = port->uartclk / (16 * (quot + 1));
 461         }
 462 }
 463
 464 static int uart_clps711x_console_setup(struct console *co, char *options)
 465 {
 466         int baud = 38400, bits = 8, parity = 'n', flow = 'n';
 467         struct clps711x_port *s = (struct clps711x_port *)co->data;
 468         struct uart_port *port = &s->port[(co->index > 0) ? co->index : 0];
 469
 470         if (options)
 471                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 472         else
 473                 uart_clps711x_console_get_options(port, &baud, &parity, &bits);
 474
 475         return uart_set_options(port, co, baud, parity, bits, flow);
 476 }
 477 #endif
 478
 479 static int __devinit uart_clps711x_probe(struct platform_device *pdev)
 480 {
 481         struct clps711x_port *s;
 482         int ret, i;
 483
 484         s = devm_kzalloc(&pdev->dev, sizeof(struct clps711x_port), GFP_KERNEL);
 485         if (!s) {
 486                 dev_err(&pdev->dev, "Error allocating port structure\n");
 487                 return -ENOMEM;
 488         }
 489         platform_set_drvdata(pdev, s);
 490
 491         s->uart_clk = devm_clk_get(&pdev->dev, "uart");
 492         if (IS_ERR(s->uart_clk)) {
 493                 dev_err(&pdev->dev, "Can't get UART clocks\n");
 494                 ret = PTR_ERR(s->uart_clk);
 495                 goto err_out;
 496         }
 497
 498         s->uart.owner           = THIS_MODULE;
 499         s->uart.dev_name        = "ttyCL";
 500         s->uart.major           = UART_CLPS711X_MAJOR;
 501         s->uart.minor           = UART_CLPS711X_MINOR;
 502         s->uart.nr              = UART_CLPS711X_NR;
 503 #ifdef CONFIG_SERIAL_CLPS711X_CONSOLE
 504         s->uart.cons            = &s->console;
 505         s->uart.cons->device    = uart_console_device;
 506         s->uart.cons->write     = uart_clps711x_console_write;
 507         s->uart.cons->setup     = uart_clps711x_console_setup;
 508         s->uart.cons->flags     = CON_PRINTBUFFER;
 509         s->uart.cons->index     = -1;
 510         s->uart.cons->data      = s;
 511         strcpy(s->uart.cons->name, "ttyCL");
 512 #endif
 513         ret = uart_register_driver(&s->uart);
 514         if (ret) {
 515                 dev_err(&pdev->dev, "Registering UART driver failed\n");
 516                 devm_clk_put(&pdev->dev, s->uart_clk);
 517                 goto err_out;
 518         }
 519
 520         for (i = 0; i < UART_CLPS711X_NR; i++) {
 521                 s->port[i].line         = i;
 522                 s->port[i].dev          = &pdev->dev;
 523                 s->port[i].irq          = TX_IRQ(&s->port[i]);
 524                 s->port[i].iobase       = SYSCON(&s->port[i]);
 525                 s->port[i].type         = PORT_CLPS711X;
 526                 s->port[i].fifosize     = 16;
 527                 s->port[i].flags        = UPF_SKIP_TEST | UPF_FIXED_TYPE;
 528                 s->port[i].uartclk      = clk_get_rate(s->uart_clk);
 529                 s->port[i].ops          = &uart_clps711x_ops;
 530                 WARN_ON(uart_add_one_port(&s->uart, &s->port[i]));
 531         }
 532
 533         return 0;
 534
 535 err_out:
 536         platform_set_drvdata(pdev, NULL);
 537
 538         return ret;
 539 }
 540
 541 static int __devexit uart_clps711x_remove(struct platform_device *pdev)
 542 {
 543         struct clps711x_port *s = platform_get_drvdata(pdev);
 544         int i;
 545
 546         for (i = 0; i < UART_CLPS711X_NR; i++)
 547                 uart_remove_one_port(&s->uart, &s->port[i]);
 548
 549         devm_clk_put(&pdev->dev, s->uart_clk);
 550         uart_unregister_driver(&s->uart);
 551         platform_set_drvdata(pdev, NULL);
 552
 553         return 0;
 554 }
 555
 556 static struct platform_driver clps711x_uart_driver = {
 557         .driver = {
 558                 .name   = UART_CLPS711X_NAME,
 559                 .owner  = THIS_MODULE,
 560         },
 561         .probe  = uart_clps711x_probe,
 562         .remove = __devexit_p(uart_clps711x_remove),
 563 };
 564 module_platform_driver(clps711x_uart_driver);
 565
 566 static struct platform_device clps711x_uart_device = {
 567         .name   = UART_CLPS711X_NAME,
 568 };
 569
 570 static int __init uart_clps711x_init(void)
 571 {
 572         return platform_device_register(&clps711x_uart_device);
 573 }
 574 module_init(uart_clps711x_init);
 575
 576 static void __exit uart_clps711x_exit(void)
 577 {
 578         platform_device_unregister(&clps711x_uart_device);
 579 }
 580 module_exit(uart_clps711x_exit);
 581
 582 MODULE_AUTHOR("Deep Blue Solutions Ltd");
 583 MODULE_DESCRIPTION("CLPS711X serial driver");
 584 MODULE_LICENSE("GPL");