Loading...
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Serial core port device driver
4 *
5 * Copyright (C) 2023 Texas Instruments Incorporated - https://www.ti.com/
6 * Author: Tony Lindgren <tony@atomide.com>
7 */
8
9#include <linux/device.h>
10#include <linux/module.h>
11#include <linux/pm_runtime.h>
12#include <linux/serial_core.h>
13#include <linux/spinlock.h>
14
15#include "serial_base.h"
16
17#define SERIAL_PORT_AUTOSUSPEND_DELAY_MS 500
18
19/* Only considers pending TX for now. Caller must take care of locking */
20static int __serial_port_busy(struct uart_port *port)
21{
22 return !uart_tx_stopped(port) &&
23 uart_circ_chars_pending(&port->state->xmit);
24}
25
26static int serial_port_runtime_resume(struct device *dev)
27{
28 struct serial_port_device *port_dev = to_serial_base_port_device(dev);
29 struct uart_port *port;
30 unsigned long flags;
31
32 port = port_dev->port;
33
34 if (port->flags & UPF_DEAD)
35 goto out;
36
37 /* Flush any pending TX for the port */
38 uart_port_lock_irqsave(port, &flags);
39 if (__serial_port_busy(port))
40 port->ops->start_tx(port);
41 uart_port_unlock_irqrestore(port, flags);
42
43out:
44 pm_runtime_mark_last_busy(dev);
45
46 return 0;
47}
48
49static int serial_port_runtime_suspend(struct device *dev)
50{
51 struct serial_port_device *port_dev = to_serial_base_port_device(dev);
52 struct uart_port *port = port_dev->port;
53 unsigned long flags;
54 bool busy;
55
56 if (port->flags & UPF_DEAD)
57 return 0;
58
59 uart_port_lock_irqsave(port, &flags);
60 busy = __serial_port_busy(port);
61 if (busy)
62 port->ops->start_tx(port);
63 uart_port_unlock_irqrestore(port, flags);
64
65 if (busy)
66 pm_runtime_mark_last_busy(dev);
67
68 return busy ? -EBUSY : 0;
69}
70
71static DEFINE_RUNTIME_DEV_PM_OPS(serial_port_pm,
72 serial_port_runtime_suspend,
73 serial_port_runtime_resume, NULL);
74
75static int serial_port_probe(struct device *dev)
76{
77 pm_runtime_enable(dev);
78 pm_runtime_set_autosuspend_delay(dev, SERIAL_PORT_AUTOSUSPEND_DELAY_MS);
79 pm_runtime_use_autosuspend(dev);
80
81 return 0;
82}
83
84static int serial_port_remove(struct device *dev)
85{
86 pm_runtime_dont_use_autosuspend(dev);
87 pm_runtime_disable(dev);
88
89 return 0;
90}
91
92/*
93 * Serial core port device init functions. Note that the physical serial
94 * port device driver may not have completed probe at this point.
95 */
96int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
97{
98 return serial_ctrl_register_port(drv, port);
99}
100EXPORT_SYMBOL(uart_add_one_port);
101
102void uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
103{
104 serial_ctrl_unregister_port(drv, port);
105}
106EXPORT_SYMBOL(uart_remove_one_port);
107
108static struct device_driver serial_port_driver = {
109 .name = "port",
110 .suppress_bind_attrs = true,
111 .probe = serial_port_probe,
112 .remove = serial_port_remove,
113 .pm = pm_ptr(&serial_port_pm),
114};
115
116int serial_base_port_init(void)
117{
118 return serial_base_driver_register(&serial_port_driver);
119}
120
121void serial_base_port_exit(void)
122{
123 serial_base_driver_unregister(&serial_port_driver);
124}
125
126MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
127MODULE_DESCRIPTION("Serial controller port driver");
128MODULE_LICENSE("GPL");
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Serial core port device driver
4 *
5 * Copyright (C) 2023 Texas Instruments Incorporated - https://www.ti.com/
6 * Author: Tony Lindgren <tony@atomide.com>
7 */
8
9#include <linux/device.h>
10#include <linux/module.h>
11#include <linux/of.h>
12#include <linux/platform_device.h>
13#include <linux/pm_runtime.h>
14#include <linux/pnp.h>
15#include <linux/property.h>
16#include <linux/serial_core.h>
17#include <linux/spinlock.h>
18
19#include "serial_base.h"
20
21#define SERIAL_PORT_AUTOSUSPEND_DELAY_MS 500
22
23/* Only considers pending TX for now. Caller must take care of locking */
24static int __serial_port_busy(struct uart_port *port)
25{
26 return !uart_tx_stopped(port) &&
27 !kfifo_is_empty(&port->state->port.xmit_fifo);
28}
29
30static int serial_port_runtime_resume(struct device *dev)
31{
32 struct serial_port_device *port_dev = to_serial_base_port_device(dev);
33 struct uart_port *port;
34 unsigned long flags;
35
36 port = port_dev->port;
37
38 if (port->flags & UPF_DEAD)
39 goto out;
40
41 /* Flush any pending TX for the port */
42 uart_port_lock_irqsave(port, &flags);
43 if (!port_dev->tx_enabled)
44 goto unlock;
45 if (__serial_port_busy(port))
46 port->ops->start_tx(port);
47
48unlock:
49 uart_port_unlock_irqrestore(port, flags);
50
51out:
52 pm_runtime_mark_last_busy(dev);
53
54 return 0;
55}
56
57static int serial_port_runtime_suspend(struct device *dev)
58{
59 struct serial_port_device *port_dev = to_serial_base_port_device(dev);
60 struct uart_port *port = port_dev->port;
61 unsigned long flags;
62 bool busy;
63
64 if (port->flags & UPF_DEAD)
65 return 0;
66
67 /*
68 * Nothing to do on pm_runtime_force_suspend(), see
69 * DEFINE_RUNTIME_DEV_PM_OPS.
70 */
71 if (!pm_runtime_enabled(dev))
72 return 0;
73
74 uart_port_lock_irqsave(port, &flags);
75 if (!port_dev->tx_enabled) {
76 uart_port_unlock_irqrestore(port, flags);
77 return 0;
78 }
79
80 busy = __serial_port_busy(port);
81 if (busy)
82 port->ops->start_tx(port);
83 uart_port_unlock_irqrestore(port, flags);
84
85 if (busy)
86 pm_runtime_mark_last_busy(dev);
87
88 return busy ? -EBUSY : 0;
89}
90
91static void serial_base_port_set_tx(struct uart_port *port,
92 struct serial_port_device *port_dev,
93 bool enabled)
94{
95 unsigned long flags;
96
97 uart_port_lock_irqsave(port, &flags);
98 port_dev->tx_enabled = enabled;
99 uart_port_unlock_irqrestore(port, flags);
100}
101
102void serial_base_port_startup(struct uart_port *port)
103{
104 struct serial_port_device *port_dev = port->port_dev;
105
106 serial_base_port_set_tx(port, port_dev, true);
107}
108
109void serial_base_port_shutdown(struct uart_port *port)
110{
111 struct serial_port_device *port_dev = port->port_dev;
112
113 serial_base_port_set_tx(port, port_dev, false);
114}
115
116static DEFINE_RUNTIME_DEV_PM_OPS(serial_port_pm,
117 serial_port_runtime_suspend,
118 serial_port_runtime_resume, NULL);
119
120static int serial_port_probe(struct device *dev)
121{
122 pm_runtime_enable(dev);
123 pm_runtime_set_autosuspend_delay(dev, SERIAL_PORT_AUTOSUSPEND_DELAY_MS);
124 pm_runtime_use_autosuspend(dev);
125
126 return 0;
127}
128
129static int serial_port_remove(struct device *dev)
130{
131 pm_runtime_dont_use_autosuspend(dev);
132 pm_runtime_disable(dev);
133
134 return 0;
135}
136
137/*
138 * Serial core port device init functions. Note that the physical serial
139 * port device driver may not have completed probe at this point.
140 */
141int uart_add_one_port(struct uart_driver *drv, struct uart_port *port)
142{
143 return serial_ctrl_register_port(drv, port);
144}
145EXPORT_SYMBOL(uart_add_one_port);
146
147void uart_remove_one_port(struct uart_driver *drv, struct uart_port *port)
148{
149 serial_ctrl_unregister_port(drv, port);
150}
151EXPORT_SYMBOL(uart_remove_one_port);
152
153/**
154 * __uart_read_properties - read firmware properties of the given UART port
155 * @port: corresponding port
156 * @use_defaults: apply defaults (when %true) or validate the values (when %false)
157 *
158 * The following device properties are supported:
159 * - clock-frequency (optional)
160 * - fifo-size (optional)
161 * - no-loopback-test (optional)
162 * - reg-shift (defaults may apply)
163 * - reg-offset (value may be validated)
164 * - reg-io-width (defaults may apply or value may be validated)
165 * - interrupts (OF only)
166 * - serial [alias ID] (OF only)
167 *
168 * If the port->dev is of struct platform_device type the interrupt line
169 * will be retrieved via platform_get_irq() call against that device.
170 * Otherwise it will be assigned by fwnode_irq_get() call. In both cases
171 * the index 0 of the resource is used.
172 *
173 * The caller is responsible to initialize the following fields of the @port
174 * ->dev (must be valid)
175 * ->flags
176 * ->iobase
177 * ->mapbase
178 * ->mapsize
179 * ->regshift (if @use_defaults is false)
180 * before calling this function. Alternatively the above mentioned fields
181 * may be zeroed, in such case the only ones, that have associated properties
182 * found, will be set to the respective values.
183 *
184 * If no error happened, the ->irq, ->mapbase, ->mapsize will be altered.
185 * The ->iotype is always altered.
186 *
187 * When @use_defaults is true and the respective property is not found
188 * the following values will be applied:
189 * ->regshift = 0
190 * In this case IRQ must be provided, otherwise an error will be returned.
191 *
192 * When @use_defaults is false and the respective property is found
193 * the following values will be validated:
194 * - reg-io-width (->iotype)
195 * - reg-offset (->mapsize against ->mapbase)
196 *
197 * Returns: 0 on success or negative errno on failure
198 */
199static int __uart_read_properties(struct uart_port *port, bool use_defaults)
200{
201 struct device *dev = port->dev;
202 u32 value;
203 int ret;
204
205 /* Read optional UART functional clock frequency */
206 device_property_read_u32(dev, "clock-frequency", &port->uartclk);
207
208 /* Read the registers alignment (default: 8-bit) */
209 ret = device_property_read_u32(dev, "reg-shift", &value);
210 if (ret)
211 port->regshift = use_defaults ? 0 : port->regshift;
212 else
213 port->regshift = value;
214
215 /* Read the registers I/O access type (default: MMIO 8-bit) */
216 ret = device_property_read_u32(dev, "reg-io-width", &value);
217 if (ret) {
218 port->iotype = port->iobase ? UPIO_PORT : UPIO_MEM;
219 } else {
220 switch (value) {
221 case 1:
222 port->iotype = UPIO_MEM;
223 break;
224 case 2:
225 port->iotype = UPIO_MEM16;
226 break;
227 case 4:
228 port->iotype = device_is_big_endian(dev) ? UPIO_MEM32BE : UPIO_MEM32;
229 break;
230 default:
231 port->iotype = UPIO_UNKNOWN;
232 if (!use_defaults) {
233 dev_err(dev, "Unsupported reg-io-width (%u)\n", value);
234 return -EINVAL;
235 }
236 break;
237 }
238 }
239
240 /* Read the address mapping base offset (default: no offset) */
241 ret = device_property_read_u32(dev, "reg-offset", &value);
242 if (ret)
243 value = 0;
244
245 /* Check for shifted address mapping overflow */
246 if (!use_defaults && port->mapsize < value) {
247 dev_err(dev, "reg-offset %u exceeds region size %pa\n", value, &port->mapsize);
248 return -EINVAL;
249 }
250
251 port->mapbase += value;
252 port->mapsize -= value;
253
254 /* Read optional FIFO size */
255 device_property_read_u32(dev, "fifo-size", &port->fifosize);
256
257 if (device_property_read_bool(dev, "no-loopback-test"))
258 port->flags |= UPF_SKIP_TEST;
259
260 /* Get index of serial line, if found in DT aliases */
261 ret = of_alias_get_id(dev_of_node(dev), "serial");
262 if (ret >= 0)
263 port->line = ret;
264
265 if (dev_is_platform(dev))
266 ret = platform_get_irq(to_platform_device(dev), 0);
267 else if (dev_is_pnp(dev)) {
268 ret = pnp_irq(to_pnp_dev(dev), 0);
269 if (ret < 0)
270 ret = -ENXIO;
271 } else
272 ret = fwnode_irq_get(dev_fwnode(dev), 0);
273 if (ret == -EPROBE_DEFER)
274 return ret;
275 if (ret > 0)
276 port->irq = ret;
277 else if (use_defaults)
278 /* By default IRQ support is mandatory */
279 return ret;
280 else
281 port->irq = 0;
282
283 port->flags |= UPF_SHARE_IRQ;
284
285 return 0;
286}
287
288int uart_read_port_properties(struct uart_port *port)
289{
290 return __uart_read_properties(port, true);
291}
292EXPORT_SYMBOL_GPL(uart_read_port_properties);
293
294int uart_read_and_validate_port_properties(struct uart_port *port)
295{
296 return __uart_read_properties(port, false);
297}
298EXPORT_SYMBOL_GPL(uart_read_and_validate_port_properties);
299
300static struct device_driver serial_port_driver = {
301 .name = "port",
302 .suppress_bind_attrs = true,
303 .probe = serial_port_probe,
304 .remove = serial_port_remove,
305 .pm = pm_ptr(&serial_port_pm),
306};
307
308int serial_base_port_init(void)
309{
310 return serial_base_driver_register(&serial_port_driver);
311}
312
313void serial_base_port_exit(void)
314{
315 serial_base_driver_unregister(&serial_port_driver);
316}
317
318MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
319MODULE_DESCRIPTION("Serial controller port driver");
320MODULE_LICENSE("GPL");