drivers/tty/serial/8250/8250_platform.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  Universal/legacy platform driver for 8250/16550-type serial ports
   4  *
   5  *  Supports:
   6  *            ISA-compatible 8250/16550 ports
   7  *            ACPI 8250/16550 ports
   8  *            PNP 8250/16550 ports
   9  *            "serial8250" platform devices
  10  */
  11 #include <linux/acpi.h>
  12 #include <linux/array_size.h>
  13 #include <linux/io.h>
  14 #include <linux/module.h>
  15 #include <linux/moduleparam.h>
  16 #include <linux/once.h>
  17 #include <linux/platform_device.h>
  18
  19 #include <linux/serial_8250.h>
  20
  21 #ifdef CONFIG_SPARC
  22 #include <linux/sunserialcore.h>
  23 #endif
  24
  25 #include "8250.h"
  26
  27 /*
  28  * Configuration:
  29  * share_irqs:     Whether we pass IRQF_SHARED to request_irq().
  30  *                 This option is unsafe when used on edge-triggered interrupts.
  31  * skip_txen_test: Force skip of txen test at init time.
  32  */
  33 unsigned int share_irqs = SERIAL8250_SHARE_IRQS;
  34 unsigned int skip_txen_test;
  35
  36 unsigned int nr_uarts = CONFIG_SERIAL_8250_RUNTIME_UARTS;
  37
  38 #include <asm/serial.h>
  39
  40 /*
  41  * SERIAL_PORT_DFNS tells us about built-in ports that have no
  42  * standard enumeration mechanism. Platforms that can find all
  43  * serial ports via mechanisms like ACPI or PCI need not supply it.
  44  */
  45 #ifndef SERIAL_PORT_DFNS
  46 #define SERIAL_PORT_DFNS
  47 #endif
  48
  49 static const struct old_serial_port old_serial_port[] = {
  50         SERIAL_PORT_DFNS /* defined in asm/serial.h */
  51 };
  52
  53 serial8250_isa_config_fn serial8250_isa_config;
  54 void serial8250_set_isa_configurator(serial8250_isa_config_fn v)
  55 {
  56         serial8250_isa_config = v;
  57 }
  58 EXPORT_SYMBOL(serial8250_set_isa_configurator);
  59
  60 static void __init __serial8250_isa_init_ports(void)
  61 {
  62         int i, irqflag = 0;
  63
  64         if (nr_uarts > UART_NR)
  65                 nr_uarts = UART_NR;
  66
  67         /*
  68          * Set up initial ISA ports based on nr_uart module param, or else
  69          * default to CONFIG_SERIAL_8250_RUNTIME_UARTS. Note that we do not
  70          * need to increase nr_uarts when setting up the initial ISA ports.
  71          */
  72         for (i = 0; i < nr_uarts; i++)
  73                 serial8250_setup_port(i);
  74
  75         /* chain base port ops to support Remote Supervisor Adapter */
  76         univ8250_port_ops = *univ8250_port_base_ops;
  77         univ8250_rsa_support(&univ8250_port_ops);
  78
  79         if (share_irqs)
  80                 irqflag = IRQF_SHARED;
  81
  82         for (i = 0; i < ARRAY_SIZE(old_serial_port) && i < nr_uarts; i++) {
  83                 struct uart_8250_port *up = serial8250_get_port(i);
  84                 struct uart_port *port = &up->port;
  85
  86                 port->iobase   = old_serial_port[i].port;
  87                 port->irq      = irq_canonicalize(old_serial_port[i].irq);
  88                 port->irqflags = 0;
  89                 port->uartclk  = old_serial_port[i].baud_base * 16;
  90                 port->flags    = old_serial_port[i].flags;
  91                 port->hub6     = 0;
  92                 port->membase  = old_serial_port[i].iomem_base;
  93                 port->iotype   = old_serial_port[i].io_type;
  94                 port->regshift = old_serial_port[i].iomem_reg_shift;
  95
  96                 port->irqflags |= irqflag;
  97                 if (serial8250_isa_config != NULL)
  98                         serial8250_isa_config(i, &up->port, &up->capabilities);
  99         }
 100 }
 101
 102 void __init serial8250_isa_init_ports(void)
 103 {
 104         DO_ONCE(__serial8250_isa_init_ports);
 105 }
 106
 107 /*
 108  * Generic 16550A platform devices
 109  */
 110 static int serial8250_probe_acpi(struct platform_device *pdev)
 111 {
 112         struct device *dev = &pdev->dev;
 113         struct uart_8250_port uart = { };
 114         struct resource *regs;
 115         unsigned char iotype;
 116         int ret, line;
 117
 118         regs = platform_get_mem_or_io(pdev, 0);
 119         if (!regs)
 120                 return dev_err_probe(dev, -EINVAL, "no registers defined\n");
 121
 122         switch (resource_type(regs)) {
 123         case IORESOURCE_IO:
 124                 uart.port.iobase = regs->start;
 125                 iotype = UPIO_PORT;
 126                 break;
 127         case IORESOURCE_MEM:
 128                 uart.port.mapbase = regs->start;
 129                 uart.port.mapsize = resource_size(regs);
 130                 uart.port.flags = UPF_IOREMAP;
 131                 iotype = UPIO_MEM;
 132                 break;
 133         default:
 134                 return -EINVAL;
 135         }
 136
 137         /* default clock frequency */
 138         uart.port.uartclk = 1843200;
 139         uart.port.type = PORT_16550A;
 140         uart.port.dev = &pdev->dev;
 141         uart.port.flags |= UPF_SKIP_TEST | UPF_BOOT_AUTOCONF;
 142
 143         ret = uart_read_and_validate_port_properties(&uart.port);
 144         /* no interrupt -> fall back to polling */
 145         if (ret == -ENXIO)
 146                 ret = 0;
 147         if (ret)
 148                 return ret;
 149
 150         /*
 151          * The previous call may not set iotype correctly when reg-io-width
 152          * property is absent and it doesn't support IO port resource.
 153          */
 154         uart.port.iotype = iotype;
 155
 156         line = serial8250_register_8250_port(&uart);
 157         if (line < 0)
 158                 return line;
 159
 160         return 0;
 161 }
 162
 163 static int serial8250_probe_platform(struct platform_device *dev, struct plat_serial8250_port *p)
 164 {
 165         struct uart_8250_port uart;
 166         int ret, i, irqflag = 0;
 167
 168         memset(&uart, 0, sizeof(uart));
 169
 170         if (share_irqs)
 171                 irqflag = IRQF_SHARED;
 172
 173         for (i = 0; p && p->flags != 0; p++, i++) {
 174                 uart.port.iobase        = p->iobase;
 175                 uart.port.membase       = p->membase;
 176                 uart.port.irq           = p->irq;
 177                 uart.port.irqflags      = p->irqflags;
 178                 uart.port.uartclk       = p->uartclk;
 179                 uart.port.regshift      = p->regshift;
 180                 uart.port.iotype        = p->iotype;
 181                 uart.port.flags         = p->flags;
 182                 uart.port.mapbase       = p->mapbase;
 183                 uart.port.mapsize       = p->mapsize;
 184                 uart.port.hub6          = p->hub6;
 185                 uart.port.has_sysrq     = p->has_sysrq;
 186                 uart.port.private_data  = p->private_data;
 187                 uart.port.type          = p->type;
 188                 uart.bugs               = p->bugs;
 189                 uart.port.serial_in     = p->serial_in;
 190                 uart.port.serial_out    = p->serial_out;
 191                 uart.dl_read            = p->dl_read;
 192                 uart.dl_write           = p->dl_write;
 193                 uart.port.handle_irq    = p->handle_irq;
 194                 uart.port.handle_break  = p->handle_break;
 195                 uart.port.set_termios   = p->set_termios;
 196                 uart.port.set_ldisc     = p->set_ldisc;
 197                 uart.port.get_mctrl     = p->get_mctrl;
 198                 uart.port.pm            = p->pm;
 199                 uart.port.dev           = &dev->dev;
 200                 uart.port.irqflags      |= irqflag;
 201                 ret = serial8250_register_8250_port(&uart);
 202                 if (ret < 0) {
 203                         dev_err(&dev->dev, "unable to register port at index %d "
 204                                 "(IO%lx MEM%llx IRQ%d): %d\n", i,
 205                                 p->iobase, (unsigned long long)p->mapbase,
 206                                 p->irq, ret);
 207                 }
 208         }
 209         return 0;
 210 }
 211
 212 /*
 213  * Register a set of serial devices attached to a platform device.
 214  * The list is terminated with a zero flags entry, which means we expect
 215  * all entries to have at least UPF_BOOT_AUTOCONF set.
 216  */
 217 static int serial8250_probe(struct platform_device *pdev)
 218 {
 219         struct device *dev = &pdev->dev;
 220         struct plat_serial8250_port *p;
 221
 222         p = dev_get_platdata(dev);
 223         if (p)
 224                 return serial8250_probe_platform(pdev, p);
 225
 226         /*
 227          * Probe platform UART devices defined using standard hardware
 228          * discovery mechanism like ACPI or DT. Support only ACPI based
 229          * serial device for now.
 230          */
 231         if (has_acpi_companion(dev))
 232                 return serial8250_probe_acpi(pdev);
 233
 234         return 0;
 235 }
 236
 237 /*
 238  * Remove serial ports registered against a platform device.
 239  */
 240 static void serial8250_remove(struct platform_device *dev)
 241 {
 242         int i;
 243
 244         for (i = 0; i < nr_uarts; i++) {
 245                 struct uart_8250_port *up = serial8250_get_port(i);
 246
 247                 if (up->port.dev == &dev->dev)
 248                         serial8250_unregister_port(i);
 249         }
 250 }
 251
 252 static int serial8250_suspend(struct platform_device *dev, pm_message_t state)
 253 {
 254         int i;
 255
 256         for (i = 0; i < UART_NR; i++) {
 257                 struct uart_8250_port *up = serial8250_get_port(i);
 258
 259                 if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
 260                         uart_suspend_port(&serial8250_reg, &up->port);
 261         }
 262
 263         return 0;
 264 }
 265
 266 static int serial8250_resume(struct platform_device *dev)
 267 {
 268         int i;
 269
 270         for (i = 0; i < UART_NR; i++) {
 271                 struct uart_8250_port *up = serial8250_get_port(i);
 272
 273                 if (up->port.type != PORT_UNKNOWN && up->port.dev == &dev->dev)
 274                         serial8250_resume_port(i);
 275         }
 276
 277         return 0;
 278 }
 279
 280 static const struct acpi_device_id acpi_platform_serial_table[] = {
 281         { "RSCV0003" }, /* RISC-V Generic 16550A UART */
 282         { }
 283 };
 284 MODULE_DEVICE_TABLE(acpi, acpi_platform_serial_table);
 285
 286 static struct platform_driver serial8250_isa_driver = {
 287         .probe          = serial8250_probe,
 288         .remove_new     = serial8250_remove,
 289         .suspend        = serial8250_suspend,
 290         .resume         = serial8250_resume,
 291         .driver         = {
 292                 .name   = "serial8250",
 293                 .acpi_match_table = acpi_platform_serial_table,
 294         },
 295 };
 296
 297 /*
 298  * This "device" covers _all_ ISA 8250-compatible serial devices listed
 299  * in the table in include/asm/serial.h.
 300  */
 301 struct platform_device *serial8250_isa_devs;
 302
 303 static int __init serial8250_init(void)
 304 {
 305         int ret;
 306
 307         if (nr_uarts == 0)
 308                 return -ENODEV;
 309
 310         serial8250_isa_init_ports();
 311
 312         pr_info("Serial: 8250/16550 driver, %d ports, IRQ sharing %s\n",
 313                 nr_uarts, str_enabled_disabled(share_irqs));
 314
 315 #ifdef CONFIG_SPARC
 316         ret = sunserial_register_minors(&serial8250_reg, UART_NR);
 317 #else
 318         serial8250_reg.nr = UART_NR;
 319         ret = uart_register_driver(&serial8250_reg);
 320 #endif
 321         if (ret)
 322                 goto out;
 323
 324         ret = serial8250_pnp_init();
 325         if (ret)
 326                 goto unreg_uart_drv;
 327
 328         serial8250_isa_devs = platform_device_alloc("serial8250", PLAT8250_DEV_LEGACY);
 329         if (!serial8250_isa_devs) {
 330                 ret = -ENOMEM;
 331                 goto unreg_pnp;
 332         }
 333
 334         ret = platform_device_add(serial8250_isa_devs);
 335         if (ret)
 336                 goto put_dev;
 337
 338         serial8250_register_ports(&serial8250_reg, &serial8250_isa_devs->dev);
 339
 340         ret = platform_driver_register(&serial8250_isa_driver);
 341         if (ret == 0)
 342                 goto out;
 343
 344         platform_device_del(serial8250_isa_devs);
 345 put_dev:
 346         platform_device_put(serial8250_isa_devs);
 347 unreg_pnp:
 348         serial8250_pnp_exit();
 349 unreg_uart_drv:
 350 #ifdef CONFIG_SPARC
 351         sunserial_unregister_minors(&serial8250_reg, UART_NR);
 352 #else
 353         uart_unregister_driver(&serial8250_reg);
 354 #endif
 355 out:
 356         return ret;
 357 }
 358 module_init(serial8250_init);
 359
 360 static void __exit serial8250_exit(void)
 361 {
 362         struct platform_device *isa_dev = serial8250_isa_devs;
 363
 364         /*
 365          * This tells serial8250_unregister_port() not to re-register
 366          * the ports (thereby making serial8250_isa_driver permanently
 367          * in use).
 368          */
 369         serial8250_isa_devs = NULL;
 370
 371         platform_driver_unregister(&serial8250_isa_driver);
 372         platform_device_unregister(isa_dev);
 373
 374         serial8250_pnp_exit();
 375
 376 #ifdef CONFIG_SPARC
 377         sunserial_unregister_minors(&serial8250_reg, UART_NR);
 378 #else
 379         uart_unregister_driver(&serial8250_reg);
 380 #endif
 381 }
 382 module_exit(serial8250_exit);
 383
 384 MODULE_LICENSE("GPL");
 385 MODULE_DESCRIPTION("Generic 8250/16x50 serial platform driver");
 386
 387 module_param_hw(share_irqs, uint, other, 0644);
 388 MODULE_PARM_DESC(share_irqs, "Share IRQs with other non-8250/16x50 devices (unsafe)");
 389
 390 module_param(nr_uarts, uint, 0644);
 391 MODULE_PARM_DESC(nr_uarts, "Maximum number of UARTs supported. (1-" __MODULE_STRING(CONFIG_SERIAL_8250_NR_UARTS) ")");
 392
 393 module_param(skip_txen_test, uint, 0644);
 394 MODULE_PARM_DESC(skip_txen_test, "Skip checking for the TXEN bug at init time");
 395
 396 MODULE_ALIAS_CHARDEV_MAJOR(TTY_MAJOR);
 397
 398 #ifdef CONFIG_SERIAL_8250_DEPRECATED_OPTIONS
 399 #ifndef MODULE
 400 /*
 401  * This module was renamed to 8250_core in 3.7. Keep the old "8250" name
 402  * working as well for the module options so we don't break people. We
 403  * need to keep the names identical and the convenient macros will happily
 404  * refuse to let us do that by failing the build with redefinition errors
 405  * of global variables. So we stick them inside a dummy function to avoid
 406  * those conflicts. The options still get parsed, and the redefined
 407  * MODULE_PARAM_PREFIX lets us keep the "8250." syntax alive.
 408  *
 409  * This is hacky.  I'm sorry.
 410  */
 411 static void __used s8250_options(void)
 412 {
 413 #undef MODULE_PARAM_PREFIX
 414 #define MODULE_PARAM_PREFIX "8250_core."
 415
 416         module_param_cb(share_irqs, &param_ops_uint, &share_irqs, 0644);
 417         module_param_cb(nr_uarts, &param_ops_uint, &nr_uarts, 0644);
 418         module_param_cb(skip_txen_test, &param_ops_uint, &skip_txen_test, 0644);
 419 }
 420 #else
 421 MODULE_ALIAS("8250_core");
 422 #endif
 423 #endif