drivers/serial/altera_juart.c

   1 /*
   2  *  linux/drivers/serial/altera_juart.c
   3  *
   4  *  Driver for Altera JTAG UART core with Avalon interface
   5  *
   6  *  Copyright 2004 Microtronix Datacom Ltd
   7  *
   8  *  Based on linux/drivers/serial/amba.c, which is
   9  *  Copyright 1999 ARM Limited
  10  *  Copyright (C) 2000 Deep Blue Solutions Ltd.
  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  * Written by Wentao Xu <wentao@microtronix.com>
  27  * Jun/20/2005   DGT Microtronix Datacom - support for
  28  *                    arch/kernel/start.c - boot time error
  29  *                    message(s).
  30  */
  31
  32 #include <linux/module.h>
  33 #include <linux/tty.h>
  34 #include <linux/ioport.h>
  35 #include <linux/init.h>
  36 #include <linux/serial.h>
  37 #include <linux/console.h>
  38 #include <linux/sysrq.h>
  39 #include <linux/device.h>
  40 #include <linux/irq.h>
  41
  42 #include <asm/io.h>
  43
  44 #if defined(CONFIG_SERIAL_AJUART_CONSOLE) && defined(CONFIG_MAGIC_SYSRQ)
  45 #define SUPPORT_SYSRQ
  46 #endif
  47
  48 #include <linux/serial_core.h>
  49
  50 #include <asm/altera_juart.h>               //;dgt;
  51
  52 #define UART_NR         1
  53
  54 #define SERIAL_JUART_MAJOR      232
  55 #define SERIAL_JUART_MINOR      16
  56 #define SERIAL_JUART_NR         UART_NR
  57
  58 #define JUART_ISR_PASS_LIMIT    16
  59
  60 /*
  61  * Register maps
  62  */
  63 #define JTAG_UARTDR             0
  64 #define JTAG_UARTCR             4
  65
  66 /*
  67  * Control Register bit definition
  68  */
  69 #define JTAG_UARTCR_RIE         1
  70 #define JTAG_UARTCR_TIE         2
  71 #define JTAG_UARTCR_RIS         (1<<8)
  72 #define JTAG_UARTCR_TIS         (1<<9)
  73 #define JTAG_UARTCR_AC          (1<<10)
  74
  75 /*
  76  * Data Register
  77  */
  78 #define JTAG_UARTDR_RVALID      (1<<15)
  79 #define JTAG_UARTDR_DATA        255
  80 /*
  81  * Access macros for the JTAG UARTs
  82  */
  83 #define UART_GET_DR(p)  readl((p)->membase + JTAG_UARTDR)
  84 #define UART_PUT_DR(p, c)       writel((c), (p)->membase + JTAG_UARTDR)
  85 #define UART_GET_CR(p)          readl((p)->membase + JTAG_UARTCR)
  86 #define UART_PUT_CR(p,c)        writel((c), (p)->membase + JTAG_UARTCR)
  87
  88 #define UART_PORT_SIZE          8
  89
  90
  91 /*
  92  * We wrap our port structure around the generic uart_port.
  93  */
  94 struct juart_port {
  95         struct uart_port        port;
  96 };
  97
  98 static void jtaguart_stop_tx(struct uart_port *port)
  99 {
 100         unsigned int cr;
 101
 102         cr = UART_GET_CR(port);
 103         cr &= ~JTAG_UARTCR_TIE;
 104         UART_PUT_CR(port, cr);
 105 }
 106
 107 static void jtaguart_start_tx(struct uart_port *port)
 108 {
 109         unsigned int cr;
 110
 111         cr = UART_GET_CR(port);
 112         cr |= JTAG_UARTCR_TIE;
 113         UART_PUT_CR(port, cr);
 114 }
 115
 116 static void jtaguart_stop_rx(struct uart_port *port)
 117 {
 118         unsigned int cr;
 119
 120         cr = UART_GET_CR(port);
 121         cr &= ~(JTAG_UARTCR_RIE);
 122         UART_PUT_CR(port, cr);
 123 }
 124
 125 static void jtaguart_enable_ms(struct uart_port *port)
 126 {
 127 }
 128
 129 static void
 130 #ifdef SUPPORT_SYSRQ
 131 jtaguart_rx_chars(struct uart_port *port)
 132 #else
 133 jtaguart_rx_chars(struct uart_port *port)
 134 #endif
 135 {
 136         struct tty_struct *tty = port->info->tty;
 137         unsigned int data, max_count = 256;
 138         unsigned char flag;
 139
 140         do {
 141                 data = UART_GET_DR(port);
 142                 if (!(data & JTAG_UARTDR_RVALID))
 143                         return;
 144
 145                 port->icount.rx++;
 146
 147                 if(!tty)
 148                         goto clear_and_exit;
 149
 150                 flag = TTY_NORMAL;
 151
 152                 if (!uart_handle_sysrq_char(port, data & JTAG_UARTDR_DATA)) {
 153                   tty_insert_flip_char(tty, data & JTAG_UARTDR_DATA, flag);
 154                 }
 155
 156         } while ((data >> 16) && (max_count--));
 157
 158
 159         tty_schedule_flip(tty);
 160
 161 clear_and_exit:
 162         return;
 163 }
 164
 165 static void jtaguart_tx_chars(struct uart_port *port)
 166 {
 167         struct circ_buf *xmit = &port->info->xmit;
 168
 169         if (port->x_char) {
 170                 UART_PUT_DR(port, port->x_char);
 171                 port->icount.tx++;
 172                 port->x_char = 0;
 173                 return;
 174         }
 175         if (uart_circ_empty(xmit) || uart_tx_stopped(port)) {
 176                 jtaguart_stop_tx(port);
 177                 return;
 178         }
 179
 180         do {
 181                 UART_PUT_DR(port, xmit->buf[xmit->tail]);
 182                 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1);
 183                 port->icount.tx++;
 184                 if (uart_circ_empty(xmit))
 185                         break;
 186         } while (UART_GET_CR(port) >> 16);
 187
 188         if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS)
 189                 uart_write_wakeup(port);
 190
 191         if (uart_circ_empty(xmit))
 192                 jtaguart_stop_tx(port);
 193 }
 194
 195 static irqreturn_t jtaguart_int(int irq, void *dev_id)
 196 {
 197         struct uart_port *port = dev_id;
 198         unsigned int status, pass_counter = JUART_ISR_PASS_LIMIT;
 199
 200         status = UART_GET_CR(port);
 201         do {
 202                 if (status & JTAG_UARTCR_RIS)
 203 #ifdef SUPPORT_SYSRQ
 204                         jtaguart_rx_chars(port, regs);
 205 #else
 206                         jtaguart_rx_chars(port);
 207 #endif
 208                 if (status & JTAG_UARTCR_TIS)
 209                         jtaguart_tx_chars(port);
 210
 211                 if (pass_counter-- == 0)
 212                         break;
 213
 214                 status = UART_GET_CR(port);
 215         } while ((status & JTAG_UARTCR_RIS) ||
 216         ((status & JTAG_UARTCR_TIS) && (status & JTAG_UARTCR_TIE)));
 217
 218         return IRQ_HANDLED;
 219 }
 220
 221 static unsigned int jtaguart_tx_empty(struct uart_port *port)
 222 {
 223         return ((UART_GET_CR(port)>>16) > 0 ) ? TIOCSER_TEMT : 0;
 224 }
 225
 226 static unsigned int jtaguart_get_mctrl(struct uart_port *port)
 227 {
 228         return (TIOCM_CAR | TIOCM_DSR | TIOCM_CTS);
 229 }
 230
 231 static void jtaguart_set_mctrl(struct uart_port *port, unsigned int mctrl)
 232 {
 233 }
 234
 235 static void jtaguart_break_ctl(struct uart_port *port, int break_state)
 236 {
 237 }
 238
 239 static int jtaguart_startup(struct uart_port *port)
 240 {
 241         //struct juart_port *uap = (struct juart_port *)port;
 242         int retval;
 243
 244         /*
 245          * Allocate the IRQ
 246          */
 247         retval = request_irq(port->irq, jtaguart_int, 0, "jtag_uart", port);
 248         if (retval)
 249                 return retval;
 250
 251         /*
 252          * Finally, enable reception interrupts
 253          */
 254         UART_PUT_CR(port, JTAG_UARTCR_RIE);
 255
 256         return 0;
 257 }
 258
 259 static void jtaguart_shutdown(struct uart_port *port)
 260 {
 261         /*
 262          * Free the interrupt
 263          */
 264         free_irq(port->irq, port);
 265
 266         /*
 267          * disable all interrupts, disable the port
 268          */
 269         UART_PUT_CR(port, 0);
 270 }
 271
 272 static void
 273 jtaguart_set_termios(struct uart_port *port, struct termios *termios,
 274                      struct termios *old)
 275 {
 276         port->read_status_mask = 0;
 277         port->ignore_status_mask = 0;
 278 }
 279
 280 static const char *jtaguart_type(struct uart_port *port)
 281 {
 282         return port->type == PORT_JTAG_UART ? "jtag_uart" : NULL;
 283 }
 284
 285 /*
 286  * Release the memory region(s) being used by 'port'
 287  */
 288 static void jtaguart_release_port(struct uart_port *port)
 289 {
 290         release_mem_region(port->mapbase, UART_PORT_SIZE);
 291 }
 292
 293 /*
 294  * Request the memory region(s) being used by 'port'
 295  */
 296 static int jtaguart_request_port(struct uart_port *port)
 297 {
 298         return request_mem_region(port->mapbase, UART_PORT_SIZE, "jtag_uart")
 299                         != NULL ? 0 : -EBUSY;
 300 }
 301
 302 /*
 303  * Configure/autoconfigure the port.
 304  */
 305 static void jtaguart_config_port(struct uart_port *port, int flags)
 306 {
 307         if (flags & UART_CONFIG_TYPE) {
 308                 port->type = PORT_JTAG_UART;
 309                 jtaguart_request_port(port);
 310         }
 311 }
 312
 313 /*
 314  * verify the new serial_struct (for TIOCSSERIAL).
 315  */
 316 static int jtaguart_verify_port(struct uart_port *port, struct serial_struct *ser)
 317 {
 318         int ret = 0;
 319         if (ser->type != PORT_UNKNOWN && ser->type != PORT_JTAG_UART)
 320                 ret = -EINVAL;
 321         if (ser->irq < 0 || ser->irq >= NR_IRQS)
 322                 ret = -EINVAL;
 323         if (ser->baud_base < 9600)
 324                 ret = -EINVAL;
 325         return ret;
 326 }
 327
 328 static struct uart_ops juart_pops = {
 329         .tx_empty       = jtaguart_tx_empty,
 330         .set_mctrl      = jtaguart_set_mctrl,
 331         .get_mctrl      = jtaguart_get_mctrl,
 332         .stop_tx        = jtaguart_stop_tx,
 333         .start_tx       = jtaguart_start_tx,
 334         .stop_rx        = jtaguart_stop_rx,
 335         .enable_ms      = jtaguart_enable_ms,
 336         .break_ctl      = jtaguart_break_ctl,
 337         .startup        = jtaguart_startup,
 338         .shutdown       = jtaguart_shutdown,
 339         .set_termios    = jtaguart_set_termios,
 340         .type           = jtaguart_type,
 341         .release_port   = jtaguart_release_port,
 342         .request_port   = jtaguart_request_port,
 343         .config_port    = jtaguart_config_port,
 344         .verify_port    = jtaguart_verify_port,
 345 };
 346
 347 static struct juart_port juart_ports[UART_NR] = {
 348         {
 349                 .port   = {
 350                         .membase        = (char*)na_jtag_uart,
 351                         .mapbase        = na_jtag_uart,
 352                         .iotype         = SERIAL_IO_MEM,
 353                         .irq            = na_jtag_uart_irq,
 354                         .uartclk        = 14745600,
 355                         .fifosize       = 64,
 356                         .ops            = &juart_pops,
 357                         .flags          = ASYNC_BOOT_AUTOCONF,
 358                         .line           = 0,
 359                 },
 360         }
 361 };
 362
 363 #ifdef CONFIG_SERIAL_AJUART_CONSOLE
 364
 365 //;dgt;static
 366  void
 367 jtaguart_console_write(struct console *co, const char *s, unsigned int count)
 368 {
 369         struct uart_port *port = &juart_ports[co->index].port;
 370         unsigned int status, old_cr;
 371         int i;
 372
 373         /*
 374          *      First save the CR then disable the interrupts
 375          */
 376         old_cr = UART_GET_CR(port);
 377         UART_PUT_CR(port, 0);
 378
 379         /*
 380          *      Now, do each character
 381          */
 382         for (i = 0; i < count; i++) {
 383                 do {
 384                         status = UART_GET_CR(port);
 385                 } while (!(status>>16));
 386                 UART_PUT_DR(port, s[i]);
 387                 if (s[i] == '\n') {
 388                         do {
 389                                 status = UART_GET_CR(port);
 390                         } while (!(status>>16));
 391                         UART_PUT_DR(port, '\r');
 392                 }
 393         }
 394
 395         /*
 396          *      Finally, wait for transmitter to become empty
 397          *      and restore the CR
 398          *  We don't have to wait until fifo is empty since
 399          *  the operation is irrevocable: all the chars can
 400          *  be deemed as "done"
 401          */
 402         /*do {
 403                 status = UART_GET_CR(port);
 404         } while ((status>>16)<port->fifosize);*/
 405         UART_PUT_CR(port, old_cr);
 406 }
 407
 408 static void __init
 409 jtaguart_console_get_options(struct uart_port *port, int *baud,
 410                              int *parity, int *bits)
 411 {
 412         *parity = 'n';
 413         *bits = 8;
 414         *baud = port->uartclk / 16;
 415 }
 416
 417 static int __init jtaguart_console_setup(struct console *co, char *options)
 418 {
 419         struct uart_port *port;
 420         int baud = 115200;
 421         int bits = 8;
 422         int parity = 'n';
 423         int flow = 'n';
 424
 425         /*
 426          * Check whether an invalid uart number has been specified, and
 427          * if so, search for the first available port that does have
 428          * console support.
 429          */
 430         if (co->index >= UART_NR)
 431                 co->index = 0;
 432         port = &juart_ports[co->index].port;
 433
 434         jtaguart_console_get_options(port, &baud, &parity, &bits);
 435
 436         return uart_set_options(port, co, baud, parity, bits, flow);
 437 }
 438
 439 extern struct uart_driver juart_reg;
 440 //;dgt;static
 441  struct console juart_console = {
 442         .name           = "ttyJ",
 443         .write          = jtaguart_console_write,
 444         .device         = uart_console_device,
 445         .setup          = jtaguart_console_setup,
 446         .flags          = CON_PRINTBUFFER,
 447         .index          = -1,
 448         .data           = &juart_reg,
 449 };
 450
 451 static int __init jtaguart_console_init(void)
 452 {
 453         register_console(&juart_console);
 454         return 0;
 455 }
 456 console_initcall(jtaguart_console_init);
 457
 458 #define JTAG_CONSOLE    &juart_console
 459 #else
 460 #define JTAG_CONSOLE    NULL
 461 #endif
 462
 463 static struct uart_driver juart_reg = {
 464         .owner                  = THIS_MODULE,
 465         .driver_name    = "ttyJ",
 466         .dev_name               = "ttyJ",
 467         .major                  = SERIAL_JUART_MAJOR,
 468         .minor                  = SERIAL_JUART_MINOR,
 469         .nr                             = SERIAL_JUART_NR,
 470         .cons                   = JTAG_CONSOLE,
 471 };
 472
 473 static int __init jtaguart_init(void)
 474 {
 475         int ret;
 476
 477         printk(KERN_INFO "Serial: JTAG UART driver $Revision: 1.3 $\n");
 478
 479         ret = uart_register_driver(&juart_reg);
 480         if (ret == 0) {
 481                 int i;
 482
 483                 for (i = 0; i < UART_NR; i++)
 484                         uart_add_one_port(&juart_reg, &juart_ports[i].port);
 485         }
 486         return ret;
 487 }
 488
 489 static void __exit jtaguart_exit(void)
 490 {
 491         int i;
 492
 493         for (i = 0; i < UART_NR; i++)
 494                 uart_remove_one_port(&juart_reg, &juart_ports[i].port);
 495
 496         uart_unregister_driver(&juart_reg);
 497 }
 498
 499 module_init(jtaguart_init);
 500 module_exit(jtaguart_exit);
 501
 502 MODULE_AUTHOR("Microtronix Datacom");
 503 MODULE_DESCRIPTION("Driver for Altera JTAG UART $Revision 1.0");
 504 MODULE_LICENSE("GPL");
 505 MODULE_ALIAS_CHARDEV(SERIAL_JUART_MAJOR, SERIAL_JUART_MINOR);