drivers/tty/serial/liteuart.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * LiteUART serial controller (LiteX) Driver
   4  *
   5  * Copyright (C) 2019-2020 Antmicro <www.antmicro.com>
   6  */
   7
   8 #include <linux/bits.h>
   9 #include <linux/console.h>
  10 #include <linux/interrupt.h>
  11 #include <linux/litex.h>
  12 #include <linux/module.h>
  13 #include <linux/of.h>
  14 #include <linux/platform_device.h>
  15 #include <linux/serial.h>
  16 #include <linux/serial_core.h>
  17 #include <linux/slab.h>
  18 #include <linux/timer.h>
  19 #include <linux/tty_flip.h>
  20 #include <linux/xarray.h>
  21
  22 /*
  23  * CSRs definitions (base address offsets + width)
  24  *
  25  * The definitions below are true for LiteX SoC configured for 8-bit CSR Bus,
  26  * 32-bit aligned.
  27  *
  28  * Supporting other configurations might require new definitions or a more
  29  * generic way of indexing the LiteX CSRs.
  30  *
  31  * For more details on how CSRs are defined and handled in LiteX, see comments
  32  * in the LiteX SoC Driver: drivers/soc/litex/litex_soc_ctrl.c
  33  */
  34 #define OFF_RXTX        0x00
  35 #define OFF_TXFULL      0x04
  36 #define OFF_RXEMPTY     0x08
  37 #define OFF_EV_STATUS   0x0c
  38 #define OFF_EV_PENDING  0x10
  39 #define OFF_EV_ENABLE   0x14
  40
  41 /* events */
  42 #define EV_TX           BIT(0)
  43 #define EV_RX           BIT(1)
  44
  45 struct liteuart_port {
  46         struct uart_port port;
  47         struct timer_list timer;
  48         u8 irq_reg;
  49 };
  50
  51 #define to_liteuart_port(port)  container_of(port, struct liteuart_port, port)
  52
  53 static DEFINE_XARRAY_FLAGS(liteuart_array, XA_FLAGS_ALLOC);
  54
  55 #ifdef CONFIG_SERIAL_LITEUART_CONSOLE
  56 static struct console liteuart_console;
  57 #endif
  58
  59 static struct uart_driver liteuart_driver = {
  60         .owner = THIS_MODULE,
  61         .driver_name = KBUILD_MODNAME,
  62         .dev_name = "ttyLXU",
  63         .major = 0,
  64         .minor = 0,
  65         .nr = CONFIG_SERIAL_LITEUART_MAX_PORTS,
  66 #ifdef CONFIG_SERIAL_LITEUART_CONSOLE
  67         .cons = &liteuart_console,
  68 #endif
  69 };
  70
  71 static void liteuart_update_irq_reg(struct uart_port *port, bool set, u8 mask)
  72 {
  73         struct liteuart_port *uart = to_liteuart_port(port);
  74
  75         if (set)
  76                 uart->irq_reg |= mask;
  77         else
  78                 uart->irq_reg &= ~mask;
  79
  80         if (port->irq)
  81                 litex_write8(port->membase + OFF_EV_ENABLE, uart->irq_reg);
  82 }
  83
  84 static void liteuart_stop_tx(struct uart_port *port)
  85 {
  86         liteuart_update_irq_reg(port, false, EV_TX);
  87 }
  88
  89 static void liteuart_start_tx(struct uart_port *port)
  90 {
  91         liteuart_update_irq_reg(port, true, EV_TX);
  92 }
  93
  94 static void liteuart_stop_rx(struct uart_port *port)
  95 {
  96         struct liteuart_port *uart = to_liteuart_port(port);
  97
  98         /* just delete timer */
  99         del_timer(&uart->timer);
 100 }
 101
 102 static void liteuart_rx_chars(struct uart_port *port)
 103 {
 104         unsigned char __iomem *membase = port->membase;
 105         u8 ch;
 106
 107         while (!litex_read8(membase + OFF_RXEMPTY)) {
 108                 ch = litex_read8(membase + OFF_RXTX);
 109                 port->icount.rx++;
 110
 111                 /* necessary for RXEMPTY to refresh its value */
 112                 litex_write8(membase + OFF_EV_PENDING, EV_RX);
 113
 114                 /* no overflow bits in status */
 115                 if (!(uart_handle_sysrq_char(port, ch)))
 116                         uart_insert_char(port, 1, 0, ch, TTY_NORMAL);
 117         }
 118
 119         tty_flip_buffer_push(&port->state->port);
 120 }
 121
 122 static void liteuart_tx_chars(struct uart_port *port)
 123 {
 124         u8 ch;
 125
 126         uart_port_tx(port, ch,
 127                 !litex_read8(port->membase + OFF_TXFULL),
 128                 litex_write8(port->membase + OFF_RXTX, ch));
 129 }
 130
 131 static irqreturn_t liteuart_interrupt(int irq, void *data)
 132 {
 133         struct liteuart_port *uart = data;
 134         struct uart_port *port = &uart->port;
 135         unsigned long flags;
 136         u8 isr;
 137
 138         /*
 139          * if polling, the context would be "in_serving_softirq", so use
 140          * irq[save|restore] spin_lock variants to cover all possibilities
 141          */
 142         uart_port_lock_irqsave(port, &flags);
 143         isr = litex_read8(port->membase + OFF_EV_PENDING) & uart->irq_reg;
 144         if (isr & EV_RX)
 145                 liteuart_rx_chars(port);
 146         if (isr & EV_TX)
 147                 liteuart_tx_chars(port);
 148         uart_port_unlock_irqrestore(port, flags);
 149
 150         return IRQ_RETVAL(isr);
 151 }
 152
 153 static void liteuart_timer(struct timer_list *t)
 154 {
 155         struct liteuart_port *uart = from_timer(uart, t, timer);
 156         struct uart_port *port = &uart->port;
 157
 158         liteuart_interrupt(0, port);
 159         mod_timer(&uart->timer, jiffies + uart_poll_timeout(port));
 160 }
 161
 162 static unsigned int liteuart_tx_empty(struct uart_port *port)
 163 {
 164         /* not really tx empty, just checking if tx is not full */
 165         if (!litex_read8(port->membase + OFF_TXFULL))
 166                 return TIOCSER_TEMT;
 167
 168         return 0;
 169 }
 170
 171 static void liteuart_set_mctrl(struct uart_port *port, unsigned int mctrl)
 172 {
 173         /* modem control register is not present in LiteUART */
 174 }
 175
 176 static unsigned int liteuart_get_mctrl(struct uart_port *port)
 177 {
 178         return TIOCM_CTS | TIOCM_DSR | TIOCM_CAR;
 179 }
 180
 181 static int liteuart_startup(struct uart_port *port)
 182 {
 183         struct liteuart_port *uart = to_liteuart_port(port);
 184         unsigned long flags;
 185         int ret;
 186
 187         if (port->irq) {
 188                 ret = request_irq(port->irq, liteuart_interrupt, 0,
 189                                   KBUILD_MODNAME, uart);
 190                 if (ret) {
 191                         dev_warn(port->dev,
 192                                 "line %d irq %d failed: switch to polling\n",
 193                                 port->line, port->irq);
 194                         port->irq = 0;
 195                 }
 196         }
 197
 198         uart_port_lock_irqsave(port, &flags);
 199         /* only enabling rx irqs during startup */
 200         liteuart_update_irq_reg(port, true, EV_RX);
 201         uart_port_unlock_irqrestore(port, flags);
 202
 203         if (!port->irq) {
 204                 timer_setup(&uart->timer, liteuart_timer, 0);
 205                 mod_timer(&uart->timer, jiffies + uart_poll_timeout(port));
 206         }
 207
 208         return 0;
 209 }
 210
 211 static void liteuart_shutdown(struct uart_port *port)
 212 {
 213         struct liteuart_port *uart = to_liteuart_port(port);
 214         unsigned long flags;
 215
 216         uart_port_lock_irqsave(port, &flags);
 217         liteuart_update_irq_reg(port, false, EV_RX | EV_TX);
 218         uart_port_unlock_irqrestore(port, flags);
 219
 220         if (port->irq)
 221                 free_irq(port->irq, port);
 222         else
 223                 del_timer_sync(&uart->timer);
 224 }
 225
 226 static void liteuart_set_termios(struct uart_port *port, struct ktermios *new,
 227                                  const struct ktermios *old)
 228 {
 229         unsigned int baud;
 230         unsigned long flags;
 231
 232         uart_port_lock_irqsave(port, &flags);
 233
 234         /* update baudrate */
 235         baud = uart_get_baud_rate(port, new, old, 0, 460800);
 236         uart_update_timeout(port, new->c_cflag, baud);
 237
 238         uart_port_unlock_irqrestore(port, flags);
 239 }
 240
 241 static const char *liteuart_type(struct uart_port *port)
 242 {
 243         return "liteuart";
 244 }
 245
 246 static void liteuart_config_port(struct uart_port *port, int flags)
 247 {
 248         /*
 249          * Driver core for serial ports forces a non-zero value for port type.
 250          * Write an arbitrary value here to accommodate the serial core driver,
 251          * as ID part of UAPI is redundant.
 252          */
 253         port->type = 1;
 254 }
 255
 256 static int liteuart_verify_port(struct uart_port *port,
 257                                 struct serial_struct *ser)
 258 {
 259         if (port->type != PORT_UNKNOWN && ser->type != 1)
 260                 return -EINVAL;
 261
 262         return 0;
 263 }
 264
 265 static const struct uart_ops liteuart_ops = {
 266         .tx_empty       = liteuart_tx_empty,
 267         .set_mctrl      = liteuart_set_mctrl,
 268         .get_mctrl      = liteuart_get_mctrl,
 269         .stop_tx        = liteuart_stop_tx,
 270         .start_tx       = liteuart_start_tx,
 271         .stop_rx        = liteuart_stop_rx,
 272         .startup        = liteuart_startup,
 273         .shutdown       = liteuart_shutdown,
 274         .set_termios    = liteuart_set_termios,
 275         .type           = liteuart_type,
 276         .config_port    = liteuart_config_port,
 277         .verify_port    = liteuart_verify_port,
 278 };
 279
 280 static int liteuart_probe(struct platform_device *pdev)
 281 {
 282         struct liteuart_port *uart;
 283         struct uart_port *port;
 284         struct xa_limit limit;
 285         int dev_id, ret;
 286
 287         uart = devm_kzalloc(&pdev->dev, sizeof(struct liteuart_port), GFP_KERNEL);
 288         if (!uart)
 289                 return -ENOMEM;
 290
 291         port = &uart->port;
 292
 293         /* get membase */
 294         port->membase = devm_platform_get_and_ioremap_resource(pdev, 0, NULL);
 295         if (IS_ERR(port->membase))
 296                 return PTR_ERR(port->membase);
 297
 298         ret = platform_get_irq_optional(pdev, 0);
 299         if (ret < 0 && ret != -ENXIO)
 300                 return ret;
 301         if (ret > 0)
 302                 port->irq = ret;
 303
 304         /* look for aliases; auto-enumerate for free index if not found */
 305         dev_id = of_alias_get_id(pdev->dev.of_node, "serial");
 306         if (dev_id < 0)
 307                 limit = XA_LIMIT(0, CONFIG_SERIAL_LITEUART_MAX_PORTS);
 308         else
 309                 limit = XA_LIMIT(dev_id, dev_id);
 310
 311         ret = xa_alloc(&liteuart_array, &dev_id, uart, limit, GFP_KERNEL);
 312         if (ret)
 313                 return ret;
 314
 315         /* values not from device tree */
 316         port->dev = &pdev->dev;
 317         port->iotype = UPIO_MEM;
 318         port->flags = UPF_BOOT_AUTOCONF;
 319         port->ops = &liteuart_ops;
 320         port->fifosize = 16;
 321         port->type = PORT_UNKNOWN;
 322         port->line = dev_id;
 323         spin_lock_init(&port->lock);
 324
 325         platform_set_drvdata(pdev, port);
 326
 327         ret = uart_add_one_port(&liteuart_driver, &uart->port);
 328         if (ret)
 329                 goto err_erase_id;
 330
 331         return 0;
 332
 333 err_erase_id:
 334         xa_erase(&liteuart_array, dev_id);
 335
 336         return ret;
 337 }
 338
 339 static void liteuart_remove(struct platform_device *pdev)
 340 {
 341         struct uart_port *port = platform_get_drvdata(pdev);
 342         unsigned int line = port->line;
 343
 344         uart_remove_one_port(&liteuart_driver, port);
 345         xa_erase(&liteuart_array, line);
 346 }
 347
 348 static const struct of_device_id liteuart_of_match[] = {
 349         { .compatible = "litex,liteuart" },
 350         {}
 351 };
 352 MODULE_DEVICE_TABLE(of, liteuart_of_match);
 353
 354 static struct platform_driver liteuart_platform_driver = {
 355         .probe = liteuart_probe,
 356         .remove = liteuart_remove,
 357         .driver = {
 358                 .name = KBUILD_MODNAME,
 359                 .of_match_table = liteuart_of_match,
 360         },
 361 };
 362
 363 #ifdef CONFIG_SERIAL_LITEUART_CONSOLE
 364
 365 static void liteuart_putchar(struct uart_port *port, unsigned char ch)
 366 {
 367         while (litex_read8(port->membase + OFF_TXFULL))
 368                 cpu_relax();
 369
 370         litex_write8(port->membase + OFF_RXTX, ch);
 371 }
 372
 373 static void liteuart_console_write(struct console *co, const char *s,
 374         unsigned int count)
 375 {
 376         struct liteuart_port *uart;
 377         struct uart_port *port;
 378         unsigned long flags;
 379
 380         uart = (struct liteuart_port *)xa_load(&liteuart_array, co->index);
 381         port = &uart->port;
 382
 383         uart_port_lock_irqsave(port, &flags);
 384         uart_console_write(port, s, count, liteuart_putchar);
 385         uart_port_unlock_irqrestore(port, flags);
 386 }
 387
 388 static int liteuart_console_setup(struct console *co, char *options)
 389 {
 390         struct liteuart_port *uart;
 391         struct uart_port *port;
 392         int baud = 115200;
 393         int bits = 8;
 394         int parity = 'n';
 395         int flow = 'n';
 396
 397         uart = (struct liteuart_port *)xa_load(&liteuart_array, co->index);
 398         if (!uart)
 399                 return -ENODEV;
 400
 401         port = &uart->port;
 402         if (!port->membase)
 403                 return -ENODEV;
 404
 405         if (options)
 406                 uart_parse_options(options, &baud, &parity, &bits, &flow);
 407
 408         return uart_set_options(port, co, baud, parity, bits, flow);
 409 }
 410
 411 static struct console liteuart_console = {
 412         .name = KBUILD_MODNAME,
 413         .write = liteuart_console_write,
 414         .device = uart_console_device,
 415         .setup = liteuart_console_setup,
 416         .flags = CON_PRINTBUFFER,
 417         .index = -1,
 418         .data = &liteuart_driver,
 419 };
 420
 421 static int __init liteuart_console_init(void)
 422 {
 423         register_console(&liteuart_console);
 424
 425         return 0;
 426 }
 427 console_initcall(liteuart_console_init);
 428
 429 static void early_liteuart_write(struct console *console, const char *s,
 430                                     unsigned int count)
 431 {
 432         struct earlycon_device *device = console->data;
 433         struct uart_port *port = &device->port;
 434
 435         uart_console_write(port, s, count, liteuart_putchar);
 436 }
 437
 438 static int __init early_liteuart_setup(struct earlycon_device *device,
 439                                        const char *options)
 440 {
 441         if (!device->port.membase)
 442                 return -ENODEV;
 443
 444         device->con->write = early_liteuart_write;
 445         return 0;
 446 }
 447
 448 OF_EARLYCON_DECLARE(liteuart, "litex,liteuart", early_liteuart_setup);
 449 #endif /* CONFIG_SERIAL_LITEUART_CONSOLE */
 450
 451 static int __init liteuart_init(void)
 452 {
 453         int res;
 454
 455         res = uart_register_driver(&liteuart_driver);
 456         if (res)
 457                 return res;
 458
 459         res = platform_driver_register(&liteuart_platform_driver);
 460         if (res)
 461                 uart_unregister_driver(&liteuart_driver);
 462
 463         return res;
 464 }
 465
 466 static void __exit liteuart_exit(void)
 467 {
 468         platform_driver_unregister(&liteuart_platform_driver);
 469         uart_unregister_driver(&liteuart_driver);
 470 }
 471
 472 module_init(liteuart_init);
 473 module_exit(liteuart_exit);
 474
 475 MODULE_AUTHOR("Antmicro <www.antmicro.com>");
 476 MODULE_DESCRIPTION("LiteUART serial driver");
 477 MODULE_LICENSE("GPL v2");
 478 MODULE_ALIAS("platform:liteuart");