1 /* 2 * timbuart.c timberdale FPGA UART driver 3 * Copyright (c) 2009 Intel Corporation 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License version 2 as 7 * published by the Free Software Foundation. 8 * 9 * This program is distributed in the hope that it will be useful, 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of 11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 12 * GNU General Public License for more details. 13 * 14 * You should have received a copy of the GNU General Public License 15 * along with this program; if not, write to the Free Software 16 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 17 */ 18 19 /* Supports: 20 * Timberdale FPGA UART 21 */ 22 23 #include <linux/pci.h> 24 #include <linux/interrupt.h> 25 #include <linux/serial_core.h> 26 #include <linux/tty.h> 27 #include <linux/tty_flip.h> 28 #include <linux/kernel.h> 29 #include <linux/platform_device.h> 30 #include <linux/ioport.h> 31 #include <linux/slab.h> 32 33 #include "timbuart.h" 34 35 struct timbuart_port { 36 struct uart_port port; 37 struct tasklet_struct tasklet; 38 int usedma; 39 u32 last_ier; 40 struct platform_device *dev; 41 }; 42 43 static int baudrates[] = {9600, 19200, 38400, 57600, 115200, 230400, 460800, 44 921600, 1843200, 3250000}; 45 46 static void timbuart_mctrl_check(struct uart_port *port, u32 isr, u32 *ier); 47 48 static irqreturn_t timbuart_handleinterrupt(int irq, void *devid); 49 50 static void timbuart_stop_rx(struct uart_port *port) 51 { 52 /* spin lock held by upper layer, disable all RX interrupts */ 53 u32 ier = ioread32(port->membase + TIMBUART_IER) & ~RXFLAGS; 54 iowrite32(ier, port->membase + TIMBUART_IER); 55 } 56 57 static void timbuart_stop_tx(struct uart_port *port) 58 { 59 /* spinlock held by upper layer, disable TX interrupt */ 60 u32 ier = ioread32(port->membase + TIMBUART_IER) & ~TXBAE; 61 iowrite32(ier, port->membase + TIMBUART_IER); 62 } 63 64 static void timbuart_start_tx(struct uart_port *port) 65 { 66 struct timbuart_port *uart = 67 container_of(port, struct timbuart_port, port); 68 69 /* do not transfer anything here -> fire off the tasklet */ 70 tasklet_schedule(&uart->tasklet); 71 } 72 73 static unsigned int timbuart_tx_empty(struct uart_port *port) 74 { 75 u32 isr = ioread32(port->membase + TIMBUART_ISR); 76 77 return (isr & TXBE) ? TIOCSER_TEMT : 0; 78 } 79 80 static void timbuart_flush_buffer(struct uart_port *port) 81 { 82 if (!timbuart_tx_empty(port)) { 83 u8 ctl = ioread8(port->membase + TIMBUART_CTRL) | 84 TIMBUART_CTRL_FLSHTX; 85 86 iowrite8(ctl, port->membase + TIMBUART_CTRL); 87 iowrite32(TXBF, port->membase + TIMBUART_ISR); 88 } 89 } 90 91 static void timbuart_rx_chars(struct uart_port *port) 92 { 93 struct tty_struct *tty = port->state->port.tty; 94 95 while (ioread32(port->membase + TIMBUART_ISR) & RXDP) { 96 u8 ch = ioread8(port->membase + TIMBUART_RXFIFO); 97 port->icount.rx++; 98 tty_insert_flip_char(tty, ch, TTY_NORMAL); 99 } 100 101 spin_unlock(&port->lock); 102 tty_flip_buffer_push(port->state->port.tty); 103 spin_lock(&port->lock); 104 105 dev_dbg(port->dev, "%s - total read %d bytes\n", 106 __func__, port->icount.rx); 107 } 108 109 static void timbuart_tx_chars(struct uart_port *port) 110 { 111 struct circ_buf *xmit = &port->state->xmit; 112 113 while (!(ioread32(port->membase + TIMBUART_ISR) & TXBF) && 114 !uart_circ_empty(xmit)) { 115 iowrite8(xmit->buf[xmit->tail], 116 port->membase + TIMBUART_TXFIFO); 117 xmit->tail = (xmit->tail + 1) & (UART_XMIT_SIZE - 1); 118 port->icount.tx++; 119 } 120 121 dev_dbg(port->dev, 122 "%s - total written %d bytes, CTL: %x, RTS: %x, baud: %x\n", 123 __func__, 124 port->icount.tx, 125 ioread8(port->membase + TIMBUART_CTRL), 126 port->mctrl & TIOCM_RTS, 127 ioread8(port->membase + TIMBUART_BAUDRATE)); 128 } 129 130 static void timbuart_handle_tx_port(struct uart_port *port, u32 isr, u32 *ier) 131 { 132 struct timbuart_port *uart = 133 container_of(port, struct timbuart_port, port); 134 struct circ_buf *xmit = &port->state->xmit; 135 136 if (uart_circ_empty(xmit) || uart_tx_stopped(port)) 137 return; 138 139 if (port->x_char) 140 return; 141 142 if (isr & TXFLAGS) { 143 timbuart_tx_chars(port); 144 /* clear all TX interrupts */ 145 iowrite32(TXFLAGS, port->membase + TIMBUART_ISR); 146 147 if (uart_circ_chars_pending(xmit) < WAKEUP_CHARS) 148 uart_write_wakeup(port); 149 } else 150 /* Re-enable any tx interrupt */ 151 *ier |= uart->last_ier & TXFLAGS; 152 153 /* enable interrupts if there are chars in the transmit buffer, 154 * Or if we delivered some bytes and want the almost empty interrupt 155 * we wake up the upper layer later when we got the interrupt 156 * to give it some time to go out... 157 */ 158 if (!uart_circ_empty(xmit)) 159 *ier |= TXBAE; 160 161 dev_dbg(port->dev, "%s - leaving\n", __func__); 162 } 163 164 void timbuart_handle_rx_port(struct uart_port *port, u32 isr, u32 *ier) 165 { 166 if (isr & RXFLAGS) { 167 /* Some RX status is set */ 168 if (isr & RXBF) { 169 u8 ctl = ioread8(port->membase + TIMBUART_CTRL) | 170 TIMBUART_CTRL_FLSHRX; 171 iowrite8(ctl, port->membase + TIMBUART_CTRL); 172 port->icount.overrun++; 173 } else if (isr & (RXDP)) 174 timbuart_rx_chars(port); 175 176 /* ack all RX interrupts */ 177 iowrite32(RXFLAGS, port->membase + TIMBUART_ISR); 178 } 179 180 /* always have the RX interrupts enabled */ 181 *ier |= RXBAF | RXBF | RXTT; 182 183 dev_dbg(port->dev, "%s - leaving\n", __func__); 184 } 185 186 void timbuart_tasklet(unsigned long arg) 187 { 188 struct timbuart_port *uart = (struct timbuart_port *)arg; 189 u32 isr, ier = 0; 190 191 spin_lock(&uart->port.lock); 192 193 isr = ioread32(uart->port.membase + TIMBUART_ISR); 194 dev_dbg(uart->port.dev, "%s ISR: %x\n", __func__, isr); 195 196 if (!uart->usedma) 197 timbuart_handle_tx_port(&uart->port, isr, &ier); 198 199 timbuart_mctrl_check(&uart->port, isr, &ier); 200 201 if (!uart->usedma) 202 timbuart_handle_rx_port(&uart->port, isr, &ier); 203 204 iowrite32(ier, uart->port.membase + TIMBUART_IER); 205 206 spin_unlock(&uart->port.lock); 207 dev_dbg(uart->port.dev, "%s leaving\n", __func__); 208 } 209 210 static unsigned int timbuart_get_mctrl(struct uart_port *port) 211 { 212 u8 cts = ioread8(port->membase + TIMBUART_CTRL); 213 dev_dbg(port->dev, "%s - cts %x\n", __func__, cts); 214 215 if (cts & TIMBUART_CTRL_CTS) 216 return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR; 217 else 218 return TIOCM_DSR | TIOCM_CAR; 219 } 220 221 static void timbuart_set_mctrl(struct uart_port *port, unsigned int mctrl) 222 { 223 dev_dbg(port->dev, "%s - %x\n", __func__, mctrl); 224 225 if (mctrl & TIOCM_RTS) 226 iowrite8(TIMBUART_CTRL_RTS, port->membase + TIMBUART_CTRL); 227 else 228 iowrite8(0, port->membase + TIMBUART_CTRL); 229 } 230 231 static void timbuart_mctrl_check(struct uart_port *port, u32 isr, u32 *ier) 232 { 233 unsigned int cts; 234 235 if (isr & CTS_DELTA) { 236 /* ack */ 237 iowrite32(CTS_DELTA, port->membase + TIMBUART_ISR); 238 cts = timbuart_get_mctrl(port); 239 uart_handle_cts_change(port, cts & TIOCM_CTS); 240 wake_up_interruptible(&port->state->port.delta_msr_wait); 241 } 242 243 *ier |= CTS_DELTA; 244 } 245 246 static void timbuart_enable_ms(struct uart_port *port) 247 { 248 /* N/A */ 249 } 250 251 static void timbuart_break_ctl(struct uart_port *port, int ctl) 252 { 253 /* N/A */ 254 } 255 256 static int timbuart_startup(struct uart_port *port) 257 { 258 struct timbuart_port *uart = 259 container_of(port, struct timbuart_port, port); 260 261 dev_dbg(port->dev, "%s\n", __func__); 262 263 iowrite8(TIMBUART_CTRL_FLSHRX, port->membase + TIMBUART_CTRL); 264 iowrite32(0x1ff, port->membase + TIMBUART_ISR); 265 /* Enable all but TX interrupts */ 266 iowrite32(RXBAF | RXBF | RXTT | CTS_DELTA, 267 port->membase + TIMBUART_IER); 268 269 return request_irq(port->irq, timbuart_handleinterrupt, IRQF_SHARED, 270 "timb-uart", uart); 271 } 272 273 static void timbuart_shutdown(struct uart_port *port) 274 { 275 struct timbuart_port *uart = 276 container_of(port, struct timbuart_port, port); 277 dev_dbg(port->dev, "%s\n", __func__); 278 free_irq(port->irq, uart); 279 iowrite32(0, port->membase + TIMBUART_IER); 280 } 281 282 static int get_bindex(int baud) 283 { 284 int i; 285 286 for (i = 0; i < ARRAY_SIZE(baudrates); i++) 287 if (baud <= baudrates[i]) 288 return i; 289 290 return -1; 291 } 292 293 static void timbuart_set_termios(struct uart_port *port, 294 struct ktermios *termios, 295 struct ktermios *old) 296 { 297 unsigned int baud; 298 short bindex; 299 unsigned long flags; 300 301 baud = uart_get_baud_rate(port, termios, old, 0, port->uartclk / 16); 302 bindex = get_bindex(baud); 303 dev_dbg(port->dev, "%s - bindex %d\n", __func__, bindex); 304 305 if (bindex < 0) 306 bindex = 0; 307 baud = baudrates[bindex]; 308 309 /* The serial layer calls into this once with old = NULL when setting 310 up initially */ 311 if (old) 312 tty_termios_copy_hw(termios, old); 313 tty_termios_encode_baud_rate(termios, baud, baud); 314 315 spin_lock_irqsave(&port->lock, flags); 316 iowrite8((u8)bindex, port->membase + TIMBUART_BAUDRATE); 317 uart_update_timeout(port, termios->c_cflag, baud); 318 spin_unlock_irqrestore(&port->lock, flags); 319 } 320 321 static const char *timbuart_type(struct uart_port *port) 322 { 323 return port->type == PORT_UNKNOWN ? "timbuart" : NULL; 324 } 325 326 /* We do not request/release mappings of the registers here, 327 * currently it's done in the proble function. 328 */ 329 static void timbuart_release_port(struct uart_port *port) 330 { 331 struct platform_device *pdev = to_platform_device(port->dev); 332 int size = 333 resource_size(platform_get_resource(pdev, IORESOURCE_MEM, 0)); 334 335 if (port->flags & UPF_IOREMAP) { 336 iounmap(port->membase); 337 port->membase = NULL; 338 } 339 340 release_mem_region(port->mapbase, size); 341 } 342 343 static int timbuart_request_port(struct uart_port *port) 344 { 345 struct platform_device *pdev = to_platform_device(port->dev); 346 int size = 347 resource_size(platform_get_resource(pdev, IORESOURCE_MEM, 0)); 348 349 if (!request_mem_region(port->mapbase, size, "timb-uart")) 350 return -EBUSY; 351 352 if (port->flags & UPF_IOREMAP) { 353 port->membase = ioremap(port->mapbase, size); 354 if (port->membase == NULL) { 355 release_mem_region(port->mapbase, size); 356 return -ENOMEM; 357 } 358 } 359 360 return 0; 361 } 362 363 static irqreturn_t timbuart_handleinterrupt(int irq, void *devid) 364 { 365 struct timbuart_port *uart = (struct timbuart_port *)devid; 366 367 if (ioread8(uart->port.membase + TIMBUART_IPR)) { 368 uart->last_ier = ioread32(uart->port.membase + TIMBUART_IER); 369 370 /* disable interrupts, the tasklet enables them again */ 371 iowrite32(0, uart->port.membase + TIMBUART_IER); 372 373 /* fire off bottom half */ 374 tasklet_schedule(&uart->tasklet); 375 376 return IRQ_HANDLED; 377 } else 378 return IRQ_NONE; 379 } 380 381 /* 382 * Configure/autoconfigure the port. 383 */ 384 static void timbuart_config_port(struct uart_port *port, int flags) 385 { 386 if (flags & UART_CONFIG_TYPE) { 387 port->type = PORT_TIMBUART; 388 timbuart_request_port(port); 389 } 390 } 391 392 static int timbuart_verify_port(struct uart_port *port, 393 struct serial_struct *ser) 394 { 395 /* we don't want the core code to modify any port params */ 396 return -EINVAL; 397 } 398 399 static struct uart_ops timbuart_ops = { 400 .tx_empty = timbuart_tx_empty, 401 .set_mctrl = timbuart_set_mctrl, 402 .get_mctrl = timbuart_get_mctrl, 403 .stop_tx = timbuart_stop_tx, 404 .start_tx = timbuart_start_tx, 405 .flush_buffer = timbuart_flush_buffer, 406 .stop_rx = timbuart_stop_rx, 407 .enable_ms = timbuart_enable_ms, 408 .break_ctl = timbuart_break_ctl, 409 .startup = timbuart_startup, 410 .shutdown = timbuart_shutdown, 411 .set_termios = timbuart_set_termios, 412 .type = timbuart_type, 413 .release_port = timbuart_release_port, 414 .request_port = timbuart_request_port, 415 .config_port = timbuart_config_port, 416 .verify_port = timbuart_verify_port 417 }; 418 419 static struct uart_driver timbuart_driver = { 420 .owner = THIS_MODULE, 421 .driver_name = "timberdale_uart", 422 .dev_name = "ttyTU", 423 .major = TIMBUART_MAJOR, 424 .minor = TIMBUART_MINOR, 425 .nr = 1 426 }; 427 428 static int __devinit timbuart_probe(struct platform_device *dev) 429 { 430 int err, irq; 431 struct timbuart_port *uart; 432 struct resource *iomem; 433 434 dev_dbg(&dev->dev, "%s\n", __func__); 435 436 uart = kzalloc(sizeof(*uart), GFP_KERNEL); 437 if (!uart) { 438 err = -EINVAL; 439 goto err_mem; 440 } 441 442 uart->usedma = 0; 443 444 uart->port.uartclk = 3250000 * 16; 445 uart->port.fifosize = TIMBUART_FIFO_SIZE; 446 uart->port.regshift = 2; 447 uart->port.iotype = UPIO_MEM; 448 uart->port.ops = &timbuart_ops; 449 uart->port.irq = 0; 450 uart->port.flags = UPF_BOOT_AUTOCONF | UPF_IOREMAP; 451 uart->port.line = 0; 452 uart->port.dev = &dev->dev; 453 454 iomem = platform_get_resource(dev, IORESOURCE_MEM, 0); 455 if (!iomem) { 456 err = -ENOMEM; 457 goto err_register; 458 } 459 uart->port.mapbase = iomem->start; 460 uart->port.membase = NULL; 461 462 irq = platform_get_irq(dev, 0); 463 if (irq < 0) { 464 err = -EINVAL; 465 goto err_register; 466 } 467 uart->port.irq = irq; 468 469 tasklet_init(&uart->tasklet, timbuart_tasklet, (unsigned long)uart); 470 471 err = uart_register_driver(&timbuart_driver); 472 if (err) 473 goto err_register; 474 475 err = uart_add_one_port(&timbuart_driver, &uart->port); 476 if (err) 477 goto err_add_port; 478 479 platform_set_drvdata(dev, uart); 480 481 return 0; 482 483 err_add_port: 484 uart_unregister_driver(&timbuart_driver); 485 err_register: 486 kfree(uart); 487 err_mem: 488 printk(KERN_ERR "timberdale: Failed to register Timberdale UART: %d\n", 489 err); 490 491 return err; 492 } 493 494 static int __devexit timbuart_remove(struct platform_device *dev) 495 { 496 struct timbuart_port *uart = platform_get_drvdata(dev); 497 498 tasklet_kill(&uart->tasklet); 499 uart_remove_one_port(&timbuart_driver, &uart->port); 500 uart_unregister_driver(&timbuart_driver); 501 kfree(uart); 502 503 return 0; 504 } 505 506 static struct platform_driver timbuart_platform_driver = { 507 .driver = { 508 .name = "timb-uart", 509 .owner = THIS_MODULE, 510 }, 511 .probe = timbuart_probe, 512 .remove = __devexit_p(timbuart_remove), 513 }; 514 515 /*--------------------------------------------------------------------------*/ 516 517 static int __init timbuart_init(void) 518 { 519 return platform_driver_register(&timbuart_platform_driver); 520 } 521 522 static void __exit timbuart_exit(void) 523 { 524 platform_driver_unregister(&timbuart_platform_driver); 525 } 526 527 module_init(timbuart_init); 528 module_exit(timbuart_exit); 529 530 MODULE_DESCRIPTION("Timberdale UART driver"); 531 MODULE_LICENSE("GPL v2"); 532 MODULE_ALIAS("platform:timb-uart"); 533 534