2 * Serial Port driver for Open Firmware platform devices
4 * Copyright (C) 2006 Arnd Bergmann <arnd@arndb.de>, IBM Corp.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #include <linux/console.h>
13 #include <linux/module.h>
14 #include <linux/slab.h>
15 #include <linux/delay.h>
16 #include <linux/serial_core.h>
17 #include <linux/serial_reg.h>
18 #include <linux/of_address.h>
19 #include <linux/of_irq.h>
20 #include <linux/of_platform.h>
21 #include <linux/nwpserial.h>
22 #include <linux/clk.h>
24 #ifdef CONFIG_SERIAL_8250_MODULE
25 #define CONFIG_SERIAL_8250 CONFIG_SERIAL_8250_MODULE
28 #include "8250/8250.h"
30 struct of_serial_info
{
36 #ifdef CONFIG_ARCH_TEGRA
37 void tegra_serial_handle_break(struct uart_port
*p
)
39 unsigned int status
, tmout
= 10000;
42 status
= p
->serial_in(p
, UART_LSR
);
43 if (status
& (UART_LSR_FIFOE
| UART_LSR_BRK_ERROR_BITS
))
44 status
= p
->serial_in(p
, UART_RX
);
53 static inline void tegra_serial_handle_break(struct uart_port
*port
)
59 * Fill a struct uart_port for a given device node
61 static int of_platform_serial_setup(struct platform_device
*ofdev
,
62 int type
, struct uart_port
*port
,
63 struct of_serial_info
*info
)
65 struct resource resource
;
66 struct device_node
*np
= ofdev
->dev
.of_node
;
70 memset(port
, 0, sizeof *port
);
71 if (of_property_read_u32(np
, "clock-frequency", &clk
)) {
73 /* Get clk rate through clk driver if present */
74 info
->clk
= devm_clk_get(&ofdev
->dev
, NULL
);
75 if (IS_ERR(info
->clk
)) {
77 "clk or clock-frequency not defined\n");
78 return PTR_ERR(info
->clk
);
81 ret
= clk_prepare_enable(info
->clk
);
85 clk
= clk_get_rate(info
->clk
);
87 /* If current-speed was set, then try not to change it. */
88 if (of_property_read_u32(np
, "current-speed", &spd
) == 0)
89 port
->custom_divisor
= clk
/ (16 * spd
);
91 ret
= of_address_to_resource(np
, 0, &resource
);
93 dev_warn(&ofdev
->dev
, "invalid address\n");
97 spin_lock_init(&port
->lock
);
98 port
->mapbase
= resource
.start
;
99 port
->mapsize
= resource_size(&resource
);
101 /* Check for shifted address mapping */
102 if (of_property_read_u32(np
, "reg-offset", &prop
) == 0)
103 port
->mapbase
+= prop
;
105 /* Check for registers offset within the devices address range */
106 if (of_property_read_u32(np
, "reg-shift", &prop
) == 0)
107 port
->regshift
= prop
;
109 /* Check for fifo size */
110 if (of_property_read_u32(np
, "fifo-size", &prop
) == 0)
111 port
->fifosize
= prop
;
113 /* Check for a fixed line number */
114 ret
= of_alias_get_id(np
, "serial");
118 port
->irq
= irq_of_parse_and_map(np
, 0);
119 port
->iotype
= UPIO_MEM
;
120 if (of_property_read_u32(np
, "reg-io-width", &prop
) == 0) {
123 port
->iotype
= UPIO_MEM
;
126 port
->iotype
= UPIO_MEM16
;
129 port
->iotype
= of_device_is_big_endian(np
) ?
130 UPIO_MEM32BE
: UPIO_MEM32
;
133 dev_warn(&ofdev
->dev
, "unsupported reg-io-width (%d)\n",
142 port
->flags
= UPF_SHARE_IRQ
| UPF_BOOT_AUTOCONF
| UPF_IOREMAP
143 | UPF_FIXED_PORT
| UPF_FIXED_TYPE
;
145 if (of_find_property(np
, "no-loopback-test", NULL
))
146 port
->flags
|= UPF_SKIP_TEST
;
148 port
->dev
= &ofdev
->dev
;
152 port
->handle_break
= tegra_serial_handle_break
;
156 port
->iotype
= UPIO_AU
;
160 if (IS_ENABLED(CONFIG_SERIAL_8250_FSL
) &&
161 (of_device_is_compatible(np
, "fsl,ns16550") ||
162 of_device_is_compatible(np
, "fsl,16550-FIFO64")))
163 port
->handle_irq
= fsl8250_handle_irq
;
168 clk_disable_unprepare(info
->clk
);
173 * Try to register a serial port
175 static const struct of_device_id of_platform_serial_table
[];
176 static int of_platform_serial_probe(struct platform_device
*ofdev
)
178 const struct of_device_id
*match
;
179 struct of_serial_info
*info
;
180 struct uart_port port
;
184 match
= of_match_device(of_platform_serial_table
, &ofdev
->dev
);
188 if (of_find_property(ofdev
->dev
.of_node
, "used-by-rtas", NULL
))
191 info
= kzalloc(sizeof(*info
), GFP_KERNEL
);
195 port_type
= (unsigned long)match
->data
;
196 ret
= of_platform_serial_setup(ofdev
, port_type
, &port
, info
);
201 #ifdef CONFIG_SERIAL_8250
202 case PORT_8250
... PORT_MAX_8250
:
204 struct uart_8250_port port8250
;
205 memset(&port8250
, 0, sizeof(port8250
));
206 port8250
.port
= port
;
209 port8250
.capabilities
= UART_CAP_FIFO
;
211 if (of_property_read_bool(ofdev
->dev
.of_node
,
212 "auto-flow-control"))
213 port8250
.capabilities
|= UART_CAP_AFE
;
215 ret
= serial8250_register_8250_port(&port8250
);
220 /* need to add code for these */
222 dev_info(&ofdev
->dev
, "Unknown serial port found, ignored\n");
229 info
->type
= port_type
;
231 platform_set_drvdata(ofdev
, info
);
235 irq_dispose_mapping(port
.irq
);
242 static int of_platform_serial_remove(struct platform_device
*ofdev
)
244 struct of_serial_info
*info
= platform_get_drvdata(ofdev
);
245 switch (info
->type
) {
246 #ifdef CONFIG_SERIAL_8250
247 case PORT_8250
... PORT_MAX_8250
:
248 serial8250_unregister_port(info
->line
);
252 /* need to add code for these */
257 clk_disable_unprepare(info
->clk
);
262 #ifdef CONFIG_PM_SLEEP
263 #ifdef CONFIG_SERIAL_8250
264 static void of_serial_suspend_8250(struct of_serial_info
*info
)
266 struct uart_8250_port
*port8250
= serial8250_get_port(info
->line
);
267 struct uart_port
*port
= &port8250
->port
;
269 serial8250_suspend_port(info
->line
);
270 if (info
->clk
&& (!uart_console(port
) || console_suspend_enabled
))
271 clk_disable_unprepare(info
->clk
);
274 static void of_serial_resume_8250(struct of_serial_info
*info
)
276 struct uart_8250_port
*port8250
= serial8250_get_port(info
->line
);
277 struct uart_port
*port
= &port8250
->port
;
279 if (info
->clk
&& (!uart_console(port
) || console_suspend_enabled
))
280 clk_prepare_enable(info
->clk
);
282 serial8250_resume_port(info
->line
);
285 static inline void of_serial_suspend_8250(struct of_serial_info
*info
)
289 static inline void of_serial_resume_8250(struct of_serial_info
*info
)
294 static int of_serial_suspend(struct device
*dev
)
296 struct of_serial_info
*info
= dev_get_drvdata(dev
);
298 switch (info
->type
) {
299 case PORT_8250
... PORT_MAX_8250
:
300 of_serial_suspend_8250(info
);
309 static int of_serial_resume(struct device
*dev
)
311 struct of_serial_info
*info
= dev_get_drvdata(dev
);
313 switch (info
->type
) {
314 case PORT_8250
... PORT_MAX_8250
:
315 of_serial_resume_8250(info
);
324 static SIMPLE_DEV_PM_OPS(of_serial_pm_ops
, of_serial_suspend
, of_serial_resume
);
327 * A few common types, add more as needed.
329 static const struct of_device_id of_platform_serial_table
[] = {
330 { .compatible
= "ns8250", .data
= (void *)PORT_8250
, },
331 { .compatible
= "ns16450", .data
= (void *)PORT_16450
, },
332 { .compatible
= "ns16550a", .data
= (void *)PORT_16550A
, },
333 { .compatible
= "ns16550", .data
= (void *)PORT_16550
, },
334 { .compatible
= "ns16750", .data
= (void *)PORT_16750
, },
335 { .compatible
= "ns16850", .data
= (void *)PORT_16850
, },
336 { .compatible
= "nvidia,tegra20-uart", .data
= (void *)PORT_TEGRA
, },
337 { .compatible
= "nxp,lpc3220-uart", .data
= (void *)PORT_LPC3220
, },
338 { .compatible
= "ralink,rt2880-uart", .data
= (void *)PORT_RT2880
, },
339 { .compatible
= "altr,16550-FIFO32",
340 .data
= (void *)PORT_ALTR_16550_F32
, },
341 { .compatible
= "altr,16550-FIFO64",
342 .data
= (void *)PORT_ALTR_16550_F64
, },
343 { .compatible
= "altr,16550-FIFO128",
344 .data
= (void *)PORT_ALTR_16550_F128
, },
345 { .compatible
= "mrvl,mmp-uart",
346 .data
= (void *)PORT_XSCALE
, },
347 { .compatible
= "mrvl,pxa-uart",
348 .data
= (void *)PORT_XSCALE
, },
349 { /* end of list */ },
351 MODULE_DEVICE_TABLE(of
, of_platform_serial_table
);
353 static struct platform_driver of_platform_serial_driver
= {
356 .of_match_table
= of_platform_serial_table
,
358 .probe
= of_platform_serial_probe
,
359 .remove
= of_platform_serial_remove
,
362 module_platform_driver(of_platform_serial_driver
);
364 MODULE_AUTHOR("Arnd Bergmann <arnd@arndb.de>");
365 MODULE_LICENSE("GPL");
366 MODULE_DESCRIPTION("Serial Port driver for Open Firmware platform devices");