2 * Synopsys DesignWare 8250 driver.
4 * Copyright 2011 Picochip, Jamie Iles.
5 * Copyright 2013 Intel Corporation
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * The Synopsys DesignWare 8250 has an extra feature whereby it detects if the
13 * LCR is written whilst busy. If it is, then a busy detect interrupt is
14 * raised, the LCR needs to be rewritten and the uart status register read.
16 #include <linux/device.h>
17 #include <linux/init.h>
19 #include <linux/module.h>
20 #include <linux/serial_8250.h>
21 #include <linux/serial_core.h>
22 #include <linux/serial_reg.h>
24 #include <linux/of_irq.h>
25 #include <linux/of_platform.h>
26 #include <linux/platform_device.h>
27 #include <linux/slab.h>
28 #include <linux/acpi.h>
29 #include <linux/clk.h>
30 #include <linux/pm_runtime.h>
34 /* Offsets for the DesignWare specific registers */
35 #define DW_UART_USR 0x1f /* UART Status Register */
36 #define DW_UART_CPR 0xf4 /* Component Parameter Register */
37 #define DW_UART_UCV 0xf8 /* UART Component Version */
39 /* Component Parameter Register bits */
40 #define DW_UART_CPR_ABP_DATA_WIDTH (3 << 0)
41 #define DW_UART_CPR_AFCE_MODE (1 << 4)
42 #define DW_UART_CPR_THRE_MODE (1 << 5)
43 #define DW_UART_CPR_SIR_MODE (1 << 6)
44 #define DW_UART_CPR_SIR_LP_MODE (1 << 7)
45 #define DW_UART_CPR_ADDITIONAL_FEATURES (1 << 8)
46 #define DW_UART_CPR_FIFO_ACCESS (1 << 9)
47 #define DW_UART_CPR_FIFO_STAT (1 << 10)
48 #define DW_UART_CPR_SHADOW (1 << 11)
49 #define DW_UART_CPR_ENCODED_PARMS (1 << 12)
50 #define DW_UART_CPR_DMA_EXTRA (1 << 13)
51 #define DW_UART_CPR_FIFO_MODE (0xff << 16)
52 /* Helper for fifo size calculation */
53 #define DW_UART_CPR_FIFO_SIZE(a) (((a >> 16) & 0xff) * 16)
62 static inline int dw8250_modify_msr(struct uart_port
*p
, int offset
, int value
)
64 struct dw8250_data
*d
= p
->private_data
;
66 /* If reading MSR, report CTS asserted when auto-CTS/RTS enabled */
67 if (offset
== UART_MSR
&& d
->last_mcr
& UART_MCR_AFE
) {
68 value
|= UART_MSR_CTS
;
69 value
&= ~UART_MSR_DCTS
;
75 static void dw8250_force_idle(struct uart_port
*p
)
77 serial8250_clear_and_reinit_fifos(container_of
78 (p
, struct uart_8250_port
, port
));
79 (void)p
->serial_in(p
, UART_RX
);
82 static void dw8250_serial_out(struct uart_port
*p
, int offset
, int value
)
84 struct dw8250_data
*d
= p
->private_data
;
86 if (offset
== UART_MCR
)
89 writeb(value
, p
->membase
+ (offset
<< p
->regshift
));
91 /* Make sure LCR write wasn't ignored */
92 if (offset
== UART_LCR
) {
95 unsigned int lcr
= p
->serial_in(p
, UART_LCR
);
96 if ((value
& ~UART_LCR_SPAR
) == (lcr
& ~UART_LCR_SPAR
))
99 writeb(value
, p
->membase
+ (UART_LCR
<< p
->regshift
));
102 * FIXME: this deadlocks if port->lock is already held
103 * dev_err(p->dev, "Couldn't set LCR to %d\n", value);
108 static unsigned int dw8250_serial_in(struct uart_port
*p
, int offset
)
110 unsigned int value
= readb(p
->membase
+ (offset
<< p
->regshift
));
112 return dw8250_modify_msr(p
, offset
, value
);
115 static void dw8250_serial_out32(struct uart_port
*p
, int offset
, int value
)
117 struct dw8250_data
*d
= p
->private_data
;
119 if (offset
== UART_LCR
)
122 writel(value
, p
->membase
+ (offset
<< p
->regshift
));
124 /* Make sure LCR write wasn't ignored */
125 if (offset
== UART_LCR
) {
128 unsigned int lcr
= p
->serial_in(p
, UART_LCR
);
129 if ((value
& ~UART_LCR_SPAR
) == (lcr
& ~UART_LCR_SPAR
))
131 dw8250_force_idle(p
);
132 writel(value
, p
->membase
+ (UART_LCR
<< p
->regshift
));
135 * FIXME: this deadlocks if port->lock is already held
136 * dev_err(p->dev, "Couldn't set LCR to %d\n", value);
141 static unsigned int dw8250_serial_in32(struct uart_port
*p
, int offset
)
143 offset
<<= p
->regshift
;
145 return readl(p
->membase
+ offset
);
148 static int dw8250_handle_irq(struct uart_port
*p
)
150 struct dw8250_data
*d
= p
->private_data
;
151 unsigned int iir
= p
->serial_in(p
, UART_IIR
);
153 if (serial8250_handle_irq(p
, iir
)) {
155 } else if ((iir
& UART_IIR_BUSY
) == UART_IIR_BUSY
) {
156 /* Clear the USR and write the LCR again. */
157 (void)p
->serial_in(p
, DW_UART_USR
);
158 p
->serial_out(p
, UART_LCR
, d
->last_lcr
);
167 dw8250_do_pm(struct uart_port
*port
, unsigned int state
, unsigned int old
)
170 pm_runtime_get_sync(port
->dev
);
172 serial8250_do_pm(port
, state
, old
);
175 pm_runtime_put_sync_suspend(port
->dev
);
178 static int dw8250_probe_of(struct uart_port
*p
)
180 struct device_node
*np
= p
->dev
->of_node
;
183 if (!of_property_read_u32(np
, "reg-io-width", &val
)) {
188 p
->iotype
= UPIO_MEM32
;
189 p
->serial_in
= dw8250_serial_in32
;
190 p
->serial_out
= dw8250_serial_out32
;
193 dev_err(p
->dev
, "unsupported reg-io-width (%u)\n", val
);
198 if (!of_property_read_u32(np
, "reg-shift", &val
))
201 /* clock got configured through clk api, all done */
205 /* try to find out clock frequency from DT as fallback */
206 if (of_property_read_u32(np
, "clock-frequency", &val
)) {
207 dev_err(p
->dev
, "clk or clock-frequency not defined\n");
216 static int dw8250_probe_acpi(struct uart_8250_port
*up
)
218 const struct acpi_device_id
*id
;
219 struct uart_port
*p
= &up
->port
;
221 id
= acpi_match_device(p
->dev
->driver
->acpi_match_table
, p
->dev
);
225 p
->iotype
= UPIO_MEM32
;
226 p
->serial_in
= dw8250_serial_in32
;
227 p
->serial_out
= dw8250_serial_out32
;
231 p
->uartclk
= (unsigned int)id
->driver_data
;
233 up
->dma
= devm_kzalloc(p
->dev
, sizeof(*up
->dma
), GFP_KERNEL
);
237 up
->dma
->rxconf
.src_maxburst
= p
->fifosize
/ 4;
238 up
->dma
->txconf
.dst_maxburst
= p
->fifosize
/ 4;
243 static inline int dw8250_probe_acpi(struct uart_8250_port
*up
)
247 #endif /* CONFIG_ACPI */
249 static void dw8250_setup_port(struct uart_8250_port
*up
)
251 struct uart_port
*p
= &up
->port
;
252 u32 reg
= readl(p
->membase
+ DW_UART_UCV
);
255 * If the Component Version Register returns zero, we know that
256 * ADDITIONAL_FEATURES are not enabled. No need to go any further.
261 dev_dbg_ratelimited(p
->dev
, "Designware UART version %c.%c%c\n",
262 (reg
>> 24) & 0xff, (reg
>> 16) & 0xff, (reg
>> 8) & 0xff);
264 reg
= readl(p
->membase
+ DW_UART_CPR
);
268 /* Select the type based on fifo */
269 if (reg
& DW_UART_CPR_FIFO_MODE
) {
270 p
->type
= PORT_16550A
;
271 p
->flags
|= UPF_FIXED_TYPE
;
272 p
->fifosize
= DW_UART_CPR_FIFO_SIZE(reg
);
273 up
->tx_loadsz
= p
->fifosize
;
274 up
->capabilities
= UART_CAP_FIFO
;
277 if (reg
& DW_UART_CPR_AFCE_MODE
)
278 up
->capabilities
|= UART_CAP_AFE
;
281 static int dw8250_probe(struct platform_device
*pdev
)
283 struct uart_8250_port uart
= {};
284 struct resource
*regs
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
285 struct resource
*irq
= platform_get_resource(pdev
, IORESOURCE_IRQ
, 0);
286 struct dw8250_data
*data
;
290 dev_err(&pdev
->dev
, "no registers/irq defined\n");
294 spin_lock_init(&uart
.port
.lock
);
295 uart
.port
.mapbase
= regs
->start
;
296 uart
.port
.irq
= irq
->start
;
297 uart
.port
.handle_irq
= dw8250_handle_irq
;
298 uart
.port
.pm
= dw8250_do_pm
;
299 uart
.port
.type
= PORT_8250
;
300 uart
.port
.flags
= UPF_SHARE_IRQ
| UPF_BOOT_AUTOCONF
| UPF_FIXED_PORT
;
301 uart
.port
.dev
= &pdev
->dev
;
303 uart
.port
.membase
= devm_ioremap(&pdev
->dev
, regs
->start
,
304 resource_size(regs
));
305 if (!uart
.port
.membase
)
308 data
= devm_kzalloc(&pdev
->dev
, sizeof(*data
), GFP_KERNEL
);
312 data
->clk
= devm_clk_get(&pdev
->dev
, NULL
);
313 if (!IS_ERR(data
->clk
)) {
314 clk_prepare_enable(data
->clk
);
315 uart
.port
.uartclk
= clk_get_rate(data
->clk
);
318 uart
.port
.iotype
= UPIO_MEM
;
319 uart
.port
.serial_in
= dw8250_serial_in
;
320 uart
.port
.serial_out
= dw8250_serial_out
;
321 uart
.port
.private_data
= data
;
323 dw8250_setup_port(&uart
);
325 if (pdev
->dev
.of_node
) {
326 err
= dw8250_probe_of(&uart
.port
);
329 } else if (ACPI_HANDLE(&pdev
->dev
)) {
330 err
= dw8250_probe_acpi(&uart
);
337 data
->line
= serial8250_register_8250_port(&uart
);
341 platform_set_drvdata(pdev
, data
);
343 pm_runtime_set_active(&pdev
->dev
);
344 pm_runtime_enable(&pdev
->dev
);
349 static int dw8250_remove(struct platform_device
*pdev
)
351 struct dw8250_data
*data
= platform_get_drvdata(pdev
);
353 pm_runtime_get_sync(&pdev
->dev
);
355 serial8250_unregister_port(data
->line
);
357 if (!IS_ERR(data
->clk
))
358 clk_disable_unprepare(data
->clk
);
360 pm_runtime_disable(&pdev
->dev
);
361 pm_runtime_put_noidle(&pdev
->dev
);
367 static int dw8250_suspend(struct device
*dev
)
369 struct dw8250_data
*data
= dev_get_drvdata(dev
);
371 serial8250_suspend_port(data
->line
);
376 static int dw8250_resume(struct device
*dev
)
378 struct dw8250_data
*data
= dev_get_drvdata(dev
);
380 serial8250_resume_port(data
->line
);
384 #endif /* CONFIG_PM */
386 #ifdef CONFIG_PM_RUNTIME
387 static int dw8250_runtime_suspend(struct device
*dev
)
389 struct dw8250_data
*data
= dev_get_drvdata(dev
);
391 if (!IS_ERR(data
->clk
))
392 clk_disable_unprepare(data
->clk
);
397 static int dw8250_runtime_resume(struct device
*dev
)
399 struct dw8250_data
*data
= dev_get_drvdata(dev
);
401 if (!IS_ERR(data
->clk
))
402 clk_prepare_enable(data
->clk
);
408 static const struct dev_pm_ops dw8250_pm_ops
= {
409 SET_SYSTEM_SLEEP_PM_OPS(dw8250_suspend
, dw8250_resume
)
410 SET_RUNTIME_PM_OPS(dw8250_runtime_suspend
, dw8250_runtime_resume
, NULL
)
413 static const struct of_device_id dw8250_of_match
[] = {
414 { .compatible
= "snps,dw-apb-uart" },
417 MODULE_DEVICE_TABLE(of
, dw8250_of_match
);
419 static const struct acpi_device_id dw8250_acpi_match
[] = {
427 MODULE_DEVICE_TABLE(acpi
, dw8250_acpi_match
);
429 static struct platform_driver dw8250_platform_driver
= {
431 .name
= "dw-apb-uart",
432 .owner
= THIS_MODULE
,
433 .pm
= &dw8250_pm_ops
,
434 .of_match_table
= dw8250_of_match
,
435 .acpi_match_table
= ACPI_PTR(dw8250_acpi_match
),
437 .probe
= dw8250_probe
,
438 .remove
= dw8250_remove
,
441 module_platform_driver(dw8250_platform_driver
);
443 MODULE_AUTHOR("Jamie Iles");
444 MODULE_LICENSE("GPL");
445 MODULE_DESCRIPTION("Synopsys DesignWare 8250 serial port driver");