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;
serial8250_set_isa_configurator(serial8250_isa_config_fn v)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
__serial8250_isa_init_ports(void)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
serial8250_isa_init_ports(void)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 */
serial8250_probe_acpi(struct platform_device * pdev)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
serial8250_probe_platform(struct platform_device * dev,struct plat_serial8250_port * p)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 */
serial8250_probe(struct platform_device * pdev)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 */
serial8250_remove(struct platform_device * dev)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
serial8250_suspend(struct platform_device * dev,pm_message_t state)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
serial8250_resume(struct platform_device * dev)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
serial8250_init(void)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
serial8250_exit(void)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 */
s8250_options(void)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, ¶m_ops_uint, &share_irqs, 0644);
417 module_param_cb(nr_uarts, ¶m_ops_uint, &nr_uarts, 0644);
418 module_param_cb(skip_txen_test, ¶m_ops_uint, &skip_txen_test, 0644);
419 }
420 #else
421 MODULE_ALIAS("8250_core");
422 #endif
423 #endif
424