1 // SPDX-License-Identifier: GPL-2.0+
3 * Serial Port driver for Open Firmware platform devices
5 * Copyright (C) 2006 Arnd Bergmann <arnd@arndb.de>, IBM Corp.
7 #include <linux/console.h>
8 #include <linux/module.h>
9 #include <linux/slab.h>
10 #include <linux/delay.h>
11 #include <linux/serial_core.h>
12 #include <linux/serial_reg.h>
13 #include <linux/of_address.h>
14 #include <linux/of_irq.h>
15 #include <linux/of_platform.h>
16 #include <linux/pm_runtime.h>
17 #include <linux/clk.h>
18 #include <linux/reset.h>
22 struct of_serial_info
{
24 struct reset_control
*rst
;
29 #ifdef CONFIG_ARCH_TEGRA
30 static void tegra_serial_handle_break(struct uart_port
*p
)
32 unsigned int status
, tmout
= 10000;
35 status
= p
->serial_in(p
, UART_LSR
);
36 if (status
& (UART_LSR_FIFOE
| UART_LSR_BRK_ERROR_BITS
))
37 status
= p
->serial_in(p
, UART_RX
);
46 static inline void tegra_serial_handle_break(struct uart_port
*port
)
52 * Fill a struct uart_port for a given device node
54 static int of_platform_serial_setup(struct platform_device
*ofdev
,
55 int type
, struct uart_port
*port
,
56 struct of_serial_info
*info
)
58 struct resource resource
;
59 struct device_node
*np
= ofdev
->dev
.of_node
;
63 memset(port
, 0, sizeof *port
);
65 pm_runtime_enable(&ofdev
->dev
);
66 pm_runtime_get_sync(&ofdev
->dev
);
68 if (of_property_read_u32(np
, "clock-frequency", &clk
)) {
70 /* Get clk rate through clk driver if present */
71 info
->clk
= devm_clk_get(&ofdev
->dev
, NULL
);
72 if (IS_ERR(info
->clk
)) {
74 "clk or clock-frequency not defined\n");
75 ret
= PTR_ERR(info
->clk
);
79 ret
= clk_prepare_enable(info
->clk
);
83 clk
= clk_get_rate(info
->clk
);
85 /* If current-speed was set, then try not to change it. */
86 if (of_property_read_u32(np
, "current-speed", &spd
) == 0)
87 port
->custom_divisor
= clk
/ (16 * spd
);
89 ret
= of_address_to_resource(np
, 0, &resource
);
91 dev_warn(&ofdev
->dev
, "invalid address\n");
95 spin_lock_init(&port
->lock
);
96 port
->mapbase
= resource
.start
;
97 port
->mapsize
= resource_size(&resource
);
99 /* Check for shifted address mapping */
100 if (of_property_read_u32(np
, "reg-offset", &prop
) == 0)
101 port
->mapbase
+= prop
;
103 /* Compatibility with the deprecated pxa driver and 8250_pxa drivers. */
104 if (of_device_is_compatible(np
, "mrvl,mmp-uart"))
107 /* Check for registers offset within the devices address range */
108 if (of_property_read_u32(np
, "reg-shift", &prop
) == 0)
109 port
->regshift
= prop
;
111 /* Check for fifo size */
112 if (of_property_read_u32(np
, "fifo-size", &prop
) == 0)
113 port
->fifosize
= prop
;
115 /* Check for a fixed line number */
116 ret
= of_alias_get_id(np
, "serial");
120 port
->irq
= irq_of_parse_and_map(np
, 0);
121 port
->iotype
= UPIO_MEM
;
122 if (of_property_read_u32(np
, "reg-io-width", &prop
) == 0) {
125 port
->iotype
= UPIO_MEM
;
128 port
->iotype
= UPIO_MEM16
;
131 port
->iotype
= of_device_is_big_endian(np
) ?
132 UPIO_MEM32BE
: UPIO_MEM32
;
135 dev_warn(&ofdev
->dev
, "unsupported reg-io-width (%d)\n",
142 info
->rst
= devm_reset_control_get_optional_shared(&ofdev
->dev
, NULL
);
143 if (IS_ERR(info
->rst
)) {
144 ret
= PTR_ERR(info
->rst
);
148 ret
= reset_control_deassert(info
->rst
);
154 port
->flags
= UPF_SHARE_IRQ
| UPF_BOOT_AUTOCONF
| UPF_IOREMAP
155 | UPF_FIXED_PORT
| UPF_FIXED_TYPE
;
157 if (of_property_read_bool(np
, "no-loopback-test"))
158 port
->flags
|= UPF_SKIP_TEST
;
160 port
->dev
= &ofdev
->dev
;
164 port
->handle_break
= tegra_serial_handle_break
;
168 port
->iotype
= UPIO_AU
;
172 if (IS_ENABLED(CONFIG_SERIAL_8250_FSL
) &&
173 (of_device_is_compatible(np
, "fsl,ns16550") ||
174 of_device_is_compatible(np
, "fsl,16550-FIFO64")))
175 port
->handle_irq
= fsl8250_handle_irq
;
179 irq_dispose_mapping(port
->irq
);
181 clk_disable_unprepare(info
->clk
);
183 pm_runtime_put_sync(&ofdev
->dev
);
184 pm_runtime_disable(&ofdev
->dev
);
189 * Try to register a serial port
191 static const struct of_device_id of_platform_serial_table
[];
192 static int of_platform_serial_probe(struct platform_device
*ofdev
)
194 const struct of_device_id
*match
;
195 struct of_serial_info
*info
;
196 struct uart_8250_port port8250
;
201 match
= of_match_device(of_platform_serial_table
, &ofdev
->dev
);
205 if (of_property_read_bool(ofdev
->dev
.of_node
, "used-by-rtas"))
208 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
212 port_type
= (unsigned long)match
->data
;
213 memset(&port8250
, 0, sizeof(port8250
));
214 ret
= of_platform_serial_setup(ofdev
, port_type
, &port8250
.port
, info
);
218 if (port8250
.port
.fifosize
)
219 port8250
.capabilities
= UART_CAP_FIFO
;
221 /* Check for TX FIFO threshold & set tx_loadsz */
222 if ((of_property_read_u32(ofdev
->dev
.of_node
, "tx-threshold",
223 &tx_threshold
) == 0) &&
224 (tx_threshold
< port8250
.port
.fifosize
))
225 port8250
.tx_loadsz
= port8250
.port
.fifosize
- tx_threshold
;
227 if (of_property_read_bool(ofdev
->dev
.of_node
, "auto-flow-control"))
228 port8250
.capabilities
|= UART_CAP_AFE
;
230 if (of_property_read_u32(ofdev
->dev
.of_node
,
231 "overrun-throttle-ms",
232 &port8250
.overrun_backoff_time_ms
) != 0)
233 port8250
.overrun_backoff_time_ms
= 0;
235 ret
= serial8250_register_8250_port(&port8250
);
239 info
->type
= port_type
;
241 platform_set_drvdata(ofdev
, info
);
244 irq_dispose_mapping(port8250
.port
.irq
);
245 pm_runtime_put_sync(&ofdev
->dev
);
246 pm_runtime_disable(&ofdev
->dev
);
247 clk_disable_unprepare(info
->clk
);
256 static int of_platform_serial_remove(struct platform_device
*ofdev
)
258 struct of_serial_info
*info
= platform_get_drvdata(ofdev
);
260 serial8250_unregister_port(info
->line
);
262 reset_control_assert(info
->rst
);
263 pm_runtime_put_sync(&ofdev
->dev
);
264 pm_runtime_disable(&ofdev
->dev
);
265 clk_disable_unprepare(info
->clk
);
270 #ifdef CONFIG_PM_SLEEP
271 static int of_serial_suspend(struct device
*dev
)
273 struct of_serial_info
*info
= dev_get_drvdata(dev
);
274 struct uart_8250_port
*port8250
= serial8250_get_port(info
->line
);
275 struct uart_port
*port
= &port8250
->port
;
277 serial8250_suspend_port(info
->line
);
279 if (!uart_console(port
) || console_suspend_enabled
) {
280 pm_runtime_put_sync(dev
);
281 clk_disable_unprepare(info
->clk
);
286 static int of_serial_resume(struct device
*dev
)
288 struct of_serial_info
*info
= dev_get_drvdata(dev
);
289 struct uart_8250_port
*port8250
= serial8250_get_port(info
->line
);
290 struct uart_port
*port
= &port8250
->port
;
292 if (!uart_console(port
) || console_suspend_enabled
) {
293 pm_runtime_get_sync(dev
);
294 clk_prepare_enable(info
->clk
);
297 serial8250_resume_port(info
->line
);
302 static SIMPLE_DEV_PM_OPS(of_serial_pm_ops
, of_serial_suspend
, of_serial_resume
);
305 * A few common types, add more as needed.
307 static const struct of_device_id of_platform_serial_table
[] = {
308 { .compatible
= "ns8250", .data
= (void *)PORT_8250
, },
309 { .compatible
= "ns16450", .data
= (void *)PORT_16450
, },
310 { .compatible
= "ns16550a", .data
= (void *)PORT_16550A
, },
311 { .compatible
= "ns16550", .data
= (void *)PORT_16550
, },
312 { .compatible
= "ns16750", .data
= (void *)PORT_16750
, },
313 { .compatible
= "ns16850", .data
= (void *)PORT_16850
, },
314 { .compatible
= "nvidia,tegra20-uart", .data
= (void *)PORT_TEGRA
, },
315 { .compatible
= "nxp,lpc3220-uart", .data
= (void *)PORT_LPC3220
, },
316 { .compatible
= "ralink,rt2880-uart", .data
= (void *)PORT_RT2880
, },
317 { .compatible
= "altr,16550-FIFO32",
318 .data
= (void *)PORT_ALTR_16550_F32
, },
319 { .compatible
= "altr,16550-FIFO64",
320 .data
= (void *)PORT_ALTR_16550_F64
, },
321 { .compatible
= "altr,16550-FIFO128",
322 .data
= (void *)PORT_ALTR_16550_F128
, },
323 { .compatible
= "mediatek,mtk-btif",
324 .data
= (void *)PORT_MTK_BTIF
, },
325 { .compatible
= "mrvl,mmp-uart",
326 .data
= (void *)PORT_XSCALE
, },
327 { .compatible
= "ti,da830-uart", .data
= (void *)PORT_DA830
, },
328 { .compatible
= "nuvoton,npcm750-uart", .data
= (void *)PORT_NPCM
, },
329 { /* end of list */ },
331 MODULE_DEVICE_TABLE(of
, of_platform_serial_table
);
333 static struct platform_driver of_platform_serial_driver
= {
336 .of_match_table
= of_platform_serial_table
,
337 .pm
= &of_serial_pm_ops
,
339 .probe
= of_platform_serial_probe
,
340 .remove
= of_platform_serial_remove
,
343 module_platform_driver(of_platform_serial_driver
);
345 MODULE_AUTHOR("Arnd Bergmann <arnd@arndb.de>");
346 MODULE_LICENSE("GPL");
347 MODULE_DESCRIPTION("Serial Port driver for Open Firmware platform devices");