drivers/serial/serial_s3c4510b.c

   1 /*
   2  *  linux/drivers/serial/serial_s3c4510b.c
   3  *
   4  *  Driver for S3C4510B serial ports
   5  *
   6  *  Copyright (c) 2004  Cucy Systems (http://www.cucy.com)
   7  *  Curt Brune <curt@cucy.com>
   8  *
   9  *  Based on drivers/char/serial_amba.c
  10  *  Based on drivers/char/serial.c, by Linus Torvalds, Theodore Ts'o.
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  *
  26  */
  27 #include <linux/config.h>
  28 #include <linux/module.h>
  29 #include <linux/errno.h>
  30 #include <linux/signal.h>
  31 #include <linux/sched.h>
  32 #include <linux/interrupt.h>
  33 #include <linux/tty.h>
  34 #include <linux/tty_flip.h>
  35 #include <linux/major.h>
  36 #include <linux/string.h>
  37 #include <linux/fcntl.h>
  38 #include <linux/ptrace.h>
  39 #include <linux/ioport.h>
  40 #include <linux/mm.h>
  41 #include <linux/slab.h>
  42 #include <linux/init.h>
  43 #include <linux/circ_buf.h>
  44 #include <linux/serial.h>
  45 #include <linux/console.h>
  46 #include <linux/sysrq.h>
  47 #include <linux/serial_core.h>
  48
  49 #include <asm/system.h>
  50 #include <asm/io.h>
  51 #include <asm/mach/irq.h>
  52 #include <asm/uaccess.h>
  53 #include <asm/bitops.h>
  54 #include <asm/arch/hardware.h>
  55 #include <asm/arch/uart.h>
  56
  57 #define __DRIVER_NAME    "Samsung S3C4510B Internal UART"
  58
  59 #define _SDEBUG
  60 #ifdef _SDEBUG
  61 #  define _DPRINTK(format, args...)  \
  62           printk (KERN_INFO "%s():%05d "format".\n" , __FUNCTION__ , __LINE__ , ## args);
  63 #else
  64 #  define _DPRINTK(format, args...)
  65 #endif
  66
  67 /**
  68  **
  69  ** Internal(private) helper functions
  70  **
  71  **/
  72
  73 static void __xmit_char(struct uart_port *port, const char ch) {
  74
  75         struct uart_regs *uart = (struct uart_regs *)port->iobase;
  76
  77         while( !uart->m_stat.bf.txBufEmpty);
  78
  79         uart->m_tx = ch;
  80
  81         if ( ch == '\n') {
  82                 while( !uart->m_stat.bf.txBufEmpty);
  83                 uart->m_tx = '\r';
  84         }
  85
  86 }
  87
  88 static void __xmit_string(struct uart_port *port, const char *p, int len)
  89 {
  90         while( len-- > 0) {
  91                 __xmit_char( port, *p++);
  92         }
  93 }
  94
  95 static void __s3c4510b_init(const struct uart_port *port, int baud)
  96 {
  97         struct uart_regs *uart = (struct uart_regs *)port->iobase;
  98         UART_CTRL      uctrl;
  99         UART_LINE_CTRL ulctrl;
 100         UART_BAUD_DIV  ubd;
 101
 102         /* Reset the UART */
 103         /* control register */
 104         uctrl.ui = 0x0;
 105         uctrl.bf.rxMode = 0x1;
 106         uctrl.bf.rxIrq = 0x1;
 107         uctrl.bf.txMode = 0x1;
 108         uctrl.bf.DSR = 0x1;
 109         uctrl.bf.sendBreak = 0x0;
 110         uctrl.bf.loopBack = 0x0;
 111         uart->m_ctrl.ui = uctrl.ui;
 112
 113         /* Set the line control register into a safe sane state */
 114         ulctrl.ui  = 0x0;
 115         ulctrl.bf.wordLen   = 0x3; /* 8 bit data */
 116         ulctrl.bf.nStop     = 0x0; /* 1 stop bit */
 117         ulctrl.bf.parity    = 0x0; /* no parity */
 118         ulctrl.bf.clk       = 0x0; /* internal clock */
 119         ulctrl.bf.infra_red = 0x0; /* no infra_red */
 120         uart->m_lineCtrl.ui = ulctrl.ui;
 121
 122         ubd.ui = 0x0;
 123
 124         /* see table on page 10-15 in SAMSUNG S3C4510B manual */
 125         /* get correct divisor */
 126         switch( baud ? baud : 19200) {
 127
 128         case 1200:
 129                 ubd.bf.cnt0 = 1301;
 130                 break;
 131
 132         case 2400:
 133                 ubd.bf.cnt0 = 650;
 134                 break;
 135
 136         case 4800:
 137                 ubd.bf.cnt0 = 324;
 138                 break;
 139
 140         case 9600:
 141                 ubd.bf.cnt0 = 162;
 142                 break;
 143
 144         case 19200:
 145                 ubd.bf.cnt0 = 80;
 146                 break;
 147
 148         case 38400:
 149                 ubd.bf.cnt0 = 40;
 150                 break;
 151
 152         case 57600:
 153                 ubd.bf.cnt0 = 26;
 154                 break;
 155
 156         case 115200:
 157                 ubd.bf.cnt0 = 13;
 158                 break;
 159         }
 160
 161         uart->m_baudDiv.ui = ubd.ui;
 162         uart->m_baudCnt = 0x0;
 163         uart->m_baudClk = 0x0;
 164
 165 }
 166
 167 /**
 168  **
 169  ** struct uart_ops functions below
 170  **
 171  **/
 172
 173 static void __s3c4510b_stop_tx(struct uart_port *port, unsigned int tty_stop)
 174 {
 175
 176 }
 177
 178
 179 static void __s3c4510b_tx_chars(struct uart_port *port)
 180 {
 181         struct circ_buf *xmit = &port->info->xmit;
 182         int count;
 183
 184         // _DPRINTK("called with info = 0x%08x", (unsigned int) port);
 185
 186         if ( port->x_char) {
 187                 __xmit_char( port, port->x_char);
 188                 port->icount.tx++;
 189                 port->x_char = 0;
 190                 return;
 191         }
 192
 193         if (uart_circ_empty( xmit) || uart_tx_stopped( port)) {
 194                 __s3c4510b_stop_tx( port, 0);
 195                 return;
 196         }
 197
 198         count = port->fifosize >> 1;
 199         do {
 200                 __xmit_char( port, xmit->buf[xmit->tail]);
 201                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 202                 port->icount.tx++;
 203                 if (uart_circ_empty(xmit))
 204                         break;
 205         } while (--count > 0);
 206
 207         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 208                 uart_write_wakeup( port);
 209
 210         if (uart_circ_empty(xmit))
 211                 __s3c4510b_stop_tx( port, 0);
 212 }
 213
 214 static void __s3c4510b_start_tx(struct uart_port *port, unsigned int tty_start)
 215 {
 216         __s3c4510b_tx_chars( port);
 217 }
 218
 219 static void __s3c4510b_send_xchar(struct uart_port *port, char ch)
 220 {
 221         _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 222 }
 223
 224 static void __s3c4510b_stop_rx(struct uart_port *port)
 225 {
 226         struct uart_regs *uart = (struct uart_regs *)port->iobase;
 227         UART_CTRL      uctrl;
 228
 229         _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 230
 231         uctrl.ui = uart->m_ctrl.ui;
 232         uctrl.bf.rxMode = 0x0;
 233         uart->m_ctrl.ui = uctrl.ui;
 234 }
 235
 236 static void __s3c4510b_enable_ms(struct uart_port *port)
 237 {
 238         _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 239 }
 240
 241 static void __s3c4510b_rx_char(struct uart_port *port)
 242 {
 243         struct uart_regs *uart = (struct uart_regs *)port->iobase;
 244         struct tty_struct *tty = port->info->tty;
 245         unsigned int ch;
 246         UART_STAT status;
 247
 248         status.ui = uart->m_stat.ui;
 249         if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
 250                 tty->flip.work.func((void *)tty);
 251                 if (tty->flip.count >= TTY_FLIPBUF_SIZE) {
 252                         printk(KERN_WARNING "TTY_DONT_FLIP set\n");
 253                         return;
 254                 }
 255         }
 256
 257         ch = uart->m_rx & 0xFF;
 258
 259         *tty->flip.char_buf_ptr = ch;
 260         *tty->flip.flag_buf_ptr = TTY_NORMAL;
 261         port->icount.rx++;
 262
 263         /*
 264          * Note that the error handling code is
 265          * out of the main execution path
 266          */
 267         if ( status.bf.breakIrq) {
 268                 port->icount.brk++;
 269                 if (uart_handle_break(port))
 270                         goto ignore_char;
 271                 *tty->flip.flag_buf_ptr = TTY_BREAK;
 272         }
 273         else if ( status.bf.parity) {
 274                 port->icount.parity++;
 275                 *tty->flip.flag_buf_ptr = TTY_PARITY;
 276         }
 277         else if ( status.bf.frame) {
 278                 port->icount.frame++;
 279                 *tty->flip.flag_buf_ptr = TTY_FRAME;
 280         }
 281         else if ( status.bf.overrun) {
 282                 port->icount.overrun++;
 283                 if ( tty->flip.count < TTY_FLIPBUF_SIZE) {
 284                         /*
 285                          * Overrun is special, since it's reported
 286                          * immediately, and doesn't affect the current
 287                          * character
 288                          */
 289                         *tty->flip.char_buf_ptr++ = 0;
 290                         *tty->flip.flag_buf_ptr++ = TTY_OVERRUN;
 291                         tty->flip.count++;
 292                 }
 293         }
 294         else {
 295                 /* no errors */
 296                 tty->flip.flag_buf_ptr++;
 297                 tty->flip.char_buf_ptr++;
 298                 tty->flip.count++;
 299         }
 300
 301 ignore_char:
 302
 303         tty_flip_buffer_push(tty);
 304
 305
 306 }
 307
 308 static irqreturn_t __s3c4510b_rx_int(int irq, void *dev_id, struct pt_regs *regs)
 309 {
 310 //      _DPRINTK("called with irq = 0x%08x", irq);
 311
 312         struct uart_port *port = dev_id;
 313
 314         LED_SET(2);
 315         __s3c4510b_rx_char( port);
 316         LED_CLR(2);
 317
 318         return IRQ_HANDLED;
 319 }
 320
 321 static irqreturn_t __s3c4510b_tx_int(int irq, void *dev_id, struct pt_regs *regs)
 322 {
 323 //      _DPRINTK("called with irq = 0x%08x", irq);
 324
 325         struct uart_port *port = dev_id;
 326
 327         LED_SET(1);
 328         __s3c4510b_start_tx( port, 0);
 329         LED_CLR(1);
 330
 331         return IRQ_HANDLED;
 332 }
 333
 334 static unsigned int __s3c4510b_tx_empty(struct uart_port *port)
 335 {
 336         struct uart_regs *uart = (struct uart_regs *)port->iobase;
 337
 338 //      _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 339
 340         return uart->m_stat.bf.txBufEmpty ? 1 : 0;
 341 }
 342
 343 static unsigned int __s3c4510b_get_mctrl(struct uart_port *port)
 344 {
 345 //      _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 346
 347         return 0;
 348 }
 349
 350 static void __s3c4510b_set_mctrl(struct uart_port *port, u_int mctrl)
 351 {
 352 //      _DPRINTK("called with port = 0x%08x, mctrl = 0x%08x", (unsigned int) port, mctrl);
 353 }
 354
 355 static void __s3c4510b_break_ctl(struct uart_port *port, int break_state)
 356 {
 357 //      _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 358 }
 359
 360 static struct irqaction __rx_irqaction[UART_NR] = {
 361         {
 362                 name:     "serial0_rx",
 363                 flags:    SA_INTERRUPT,
 364                 handler:  __s3c4510b_rx_int,
 365         },
 366         {
 367                 name:     "serial1_rx",
 368                 flags:    SA_INTERRUPT,
 369                 handler:  __s3c4510b_rx_int,
 370         },
 371 };
 372
 373 static struct irqaction __tx_irqaction[UART_NR] = {
 374         {
 375                 name:     "serial0_tx",
 376                 flags:    SA_INTERRUPT,
 377                 handler:  __s3c4510b_tx_int,
 378         },
 379         {
 380                 name:     "serial1_tx",
 381                 flags:    SA_INTERRUPT,
 382                 handler:  __s3c4510b_tx_int,
 383         },
 384 };
 385
 386 static int __s3c4510b_startup(struct uart_port *port)
 387 {
 388         int status;
 389
 390 //      _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 391
 392         __s3c4510b_init(port, 19200);
 393
 394         /*
 395          * Allocate the IRQs for TX and RX
 396          */
 397         __tx_irqaction[port->line].dev_id = (void *)port;
 398         __rx_irqaction[port->line].dev_id = (void *)port;
 399
 400         status = setup_irq( port->irq, &__tx_irqaction[port->line]);
 401         if ( status) {
 402                 printk( KERN_ERR "Unabled to hook interrupt for serial %d TX\n", port->line);
 403                 return status;
 404         }
 405
 406         status = setup_irq( port->irq+1, &__rx_irqaction[port->line]);
 407         if ( status) {
 408                 printk( KERN_ERR "Unabled to hook interrupt for serial %d RX\n", port->line);
 409                 return status;
 410         }
 411
 412         /*
 413          * Finally, enable interrupts
 414          */
 415         spin_lock_irq( &port->lock);
 416         INT_ENABLE( port->irq);
 417         INT_ENABLE( port->irq+1);
 418         spin_unlock_irq( &port->lock);
 419
 420         return 0;
 421 }
 422
 423 static void __s3c4510b_shutdown(struct uart_port *port)
 424 {
 425         struct uart_regs *uart = (struct uart_regs *)port->iobase;
 426
 427         // _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 428
 429         INT_DISABLE( port->irq);
 430         INT_DISABLE( port->irq+1);
 431
 432         /* turn off TX/RX */
 433         uart->m_ctrl.ui = 0x0;
 434
 435 }
 436
 437 static void __s3c4510b_set_termios(struct uart_port *port, struct termios *termios, struct termios *old)
 438 {
 439 //      _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 440
 441         /**
 442          ** Ignore -- only 19200 baud supported
 443          **/
 444
 445         /*
 446          * Update the per-port timeout.
 447          */
 448         uart_update_timeout(port, termios->c_cflag, 19200);
 449
 450 }
 451
 452 static void __s3c4510b_pm(struct uart_port *port, unsigned int state, unsigned int oldstate)
 453 {
 454 //      _DPRINTK("called with port = 0x%08x, state = %u", (unsigned int) port, state);
 455 }
 456
 457 static int __s3c4510b_set_wake(struct uart_port *port, unsigned int state)
 458 {
 459 //      _DPRINTK("called with port = 0x%08x, state = %u", (unsigned int) port, state);
 460         return 0;
 461 }
 462
 463 static const char *__s3c4510b_type(struct uart_port *port)
 464 {
 465         return __DRIVER_NAME;
 466 }
 467
 468
 469 static void __s3c4510b_release_port(struct uart_port *port)
 470 {
 471 //      _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 472 }
 473
 474 static int __s3c4510b_request_port(struct uart_port *port)
 475 {
 476 //      _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 477         return 0;
 478 }
 479
 480 static void __s3c4510b_config_port(struct uart_port *port, int config)
 481 {
 482 //      _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 483 }
 484
 485 static int __s3c4510b_verify_port(struct uart_port *port, struct serial_struct *serial)
 486 {
 487 //      _DPRINTK("called with port = 0x%08x", (unsigned int) port);
 488         return 0;
 489 }
 490
 491 #if 0
 492 static int __s3c4510b_ioctl(struct uart_port *port, unsigned int cmd, unsigned long arg)
 493 {
 494 //      _DPRINTK("called with port = 0x%08x, cmd %u, arg 0x%08lx", (unsigned int) port, cmd, arg);
 495         return 0;
 496 }
 497 #endif
 498
 499 static struct uart_ops s3c4510b_pops = {
 500         tx_empty:       __s3c4510b_tx_empty,
 501         set_mctrl:      __s3c4510b_set_mctrl,
 502         get_mctrl:      __s3c4510b_get_mctrl,
 503         stop_tx:        __s3c4510b_stop_tx,
 504         start_tx:       __s3c4510b_start_tx,
 505         send_xchar:     __s3c4510b_send_xchar,
 506         stop_rx:        __s3c4510b_stop_rx,
 507         enable_ms:      __s3c4510b_enable_ms,
 508         break_ctl:      __s3c4510b_break_ctl,
 509         startup:        __s3c4510b_startup,
 510         shutdown:       __s3c4510b_shutdown,
 511         set_termios:    __s3c4510b_set_termios,
 512         pm:             __s3c4510b_pm,
 513         set_wake:       __s3c4510b_set_wake,
 514         type:           __s3c4510b_type,
 515         release_port:   __s3c4510b_release_port,
 516         request_port:   __s3c4510b_request_port,
 517         config_port:    __s3c4510b_config_port,
 518         verify_port:    __s3c4510b_verify_port,
 519 //      ioctl:          __s3c4510b_ioctl,
 520 };
 521
 522
 523 static struct uart_port __s3c4510b_ports[UART_NR] = {
 524         {
 525                 iobase:                 UART0_BASE,
 526                 line:                   0,
 527                 irq:                    INT_UARTTX0,
 528                 fifosize:               1,
 529                 ops:                    &s3c4510b_pops,
 530                 ignore_status_mask:     0x0000000F,
 531                 type:                   PORT_S3C4510B,
 532         },
 533         {
 534                 iobase:                 UART1_BASE,
 535                 line:                   1,
 536                 irq:                    INT_UARTTX1,
 537                 fifosize:               1,
 538                 ops:                    &s3c4510b_pops,
 539                 ignore_status_mask:     0x0000000F,
 540                 type:                   PORT_S3C4510B,
 541         }
 542 };
 543
 544 #ifdef CONFIG_SERIAL_S3C4510B_CONSOLE
 545 /************** console driver *****************/
 546
 547 static void __s3c4510b_console_write(struct console *co, const char *s, u_int count)
 548 {
 549         struct uart_port *port = &__s3c4510b_ports[co->index];
 550
 551         __xmit_string( port, s, count);
 552
 553 }
 554
 555 static int __init __s3c4510b_console_setup(struct console *co, char *options)
 556 {
 557         struct uart_port *port;
 558         int baud = 19200;
 559         int bits = 8;
 560         int parity = 'n';
 561         int flow = 0;
 562
 563         /*
 564          * Check whether an invalid uart number has been specified, and
 565          * if so, search for the first available port that does have
 566          * console support.
 567          */
 568         port = uart_get_console(__s3c4510b_ports, UART_NR, co);
 569
 570 //      _DPRINTK("using port = 0x%08x", (unsigned int) port);
 571
 572         if (options)
 573                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 574
 575         __s3c4510b_init(port, baud);
 576
 577         return uart_set_options(port, co, baud, parity, bits, flow);
 578 }
 579
 580 extern struct uart_driver __s3c4510b_driver;
 581 static struct console __s3c4510b_console = {
 582         name:           "ttyS",
 583         write:          __s3c4510b_console_write,
 584         device:         uart_console_device,
 585         setup:          __s3c4510b_console_setup,
 586         flags:          CON_PRINTBUFFER,
 587         index:          -1,
 588         data:           &__s3c4510b_driver,
 589 };
 590
 591 static int __init __s3c4510b_console_init(void)
 592 {
 593         register_console(&__s3c4510b_console);
 594         return 0;
 595 }
 596
 597 console_initcall(__s3c4510b_console_init);
 598
 599 #endif /* CONFIG_SERIAL_S3C4510B_CONSOLE */
 600
 601
 602 static struct uart_driver __s3c4510b_driver = {
 603         owner:           THIS_MODULE,
 604         driver_name:     __DRIVER_NAME,
 605         dev_name:        "ttyS",
 606         major:           TTY_MAJOR,
 607         minor:           64,
 608         nr:              UART_NR,
 609 #ifdef CONFIG_SERIAL_S3C4510B_CONSOLE
 610         cons:            &__s3c4510b_console,
 611 #endif
 612 };
 613
 614 static int __init __s3c4510b_serial_init(void)
 615 {
 616
 617         int    status, i;
 618
 619 //      _DPRINTK("initializing driver with drv = 0x%08x", (unsigned int) &__s3c4510b_driver);
 620
 621         status = uart_register_driver( &__s3c4510b_driver);
 622
 623         if ( status) {
 624                 _DPRINTK("uart_register_driver() returned %d", status);
 625         }
 626
 627         for ( i = 0; i < UART_NR; i++) {
 628                 status = uart_add_one_port( &__s3c4510b_driver, &__s3c4510b_ports[i]);
 629                 if ( status) {
 630                         _DPRINTK("uart_add_one_port(%d) returned %d", i, status);
 631                 }
 632         }
 633
 634         return 0;
 635 }
 636
 637 module_init(__s3c4510b_serial_init);
 638