Loading...
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Serial base bus layer for controllers
4 *
5 * Copyright (C) 2023 Texas Instruments Incorporated - https://www.ti.com/
6 * Author: Tony Lindgren <tony@atomide.com>
7 *
8 * The serial core bus manages the serial core controller instances.
9 */
10
11#include <linux/cleanup.h>
12#include <linux/container_of.h>
13#include <linux/device.h>
14#include <linux/idr.h>
15#include <linux/module.h>
16#include <linux/serial_core.h>
17#include <linux/slab.h>
18#include <linux/spinlock.h>
19
20#include "serial_base.h"
21
22static bool serial_base_initialized;
23
24static const struct device_type serial_ctrl_type = {
25 .name = "ctrl",
26};
27
28static const struct device_type serial_port_type = {
29 .name = "port",
30};
31
32static int serial_base_match(struct device *dev, const struct device_driver *drv)
33{
34 if (dev->type == &serial_ctrl_type &&
35 str_has_prefix(drv->name, serial_ctrl_type.name))
36 return 1;
37
38 if (dev->type == &serial_port_type &&
39 str_has_prefix(drv->name, serial_port_type.name))
40 return 1;
41
42 return 0;
43}
44
45static const struct bus_type serial_base_bus_type = {
46 .name = "serial-base",
47 .match = serial_base_match,
48};
49
50int serial_base_driver_register(struct device_driver *driver)
51{
52 driver->bus = &serial_base_bus_type;
53
54 return driver_register(driver);
55}
56
57void serial_base_driver_unregister(struct device_driver *driver)
58{
59 driver_unregister(driver);
60}
61
62static int serial_base_device_init(struct uart_port *port,
63 struct device *dev,
64 struct device *parent_dev,
65 const struct device_type *type,
66 void (*release)(struct device *dev),
67 unsigned int ctrl_id,
68 unsigned int port_id)
69{
70 device_initialize(dev);
71 dev->type = type;
72 dev->parent = parent_dev;
73 dev->bus = &serial_base_bus_type;
74 dev->release = release;
75
76 if (!serial_base_initialized) {
77 dev_dbg(port->dev, "uart_add_one_port() called before arch_initcall()?\n");
78 return -EPROBE_DEFER;
79 }
80
81 if (type == &serial_ctrl_type)
82 return dev_set_name(dev, "%s:%d", dev_name(port->dev), ctrl_id);
83
84 if (type == &serial_port_type)
85 return dev_set_name(dev, "%s:%d.%d", dev_name(port->dev),
86 ctrl_id, port_id);
87
88 return -EINVAL;
89}
90
91static void serial_base_ctrl_release(struct device *dev)
92{
93 struct serial_ctrl_device *ctrl_dev = to_serial_base_ctrl_device(dev);
94
95 kfree(ctrl_dev);
96}
97
98void serial_base_ctrl_device_remove(struct serial_ctrl_device *ctrl_dev)
99{
100 if (!ctrl_dev)
101 return;
102
103 device_del(&ctrl_dev->dev);
104 put_device(&ctrl_dev->dev);
105}
106
107struct serial_ctrl_device *serial_base_ctrl_add(struct uart_port *port,
108 struct device *parent)
109{
110 struct serial_ctrl_device *ctrl_dev;
111 int err;
112
113 ctrl_dev = kzalloc(sizeof(*ctrl_dev), GFP_KERNEL);
114 if (!ctrl_dev)
115 return ERR_PTR(-ENOMEM);
116
117 ida_init(&ctrl_dev->port_ida);
118
119 err = serial_base_device_init(port, &ctrl_dev->dev,
120 parent, &serial_ctrl_type,
121 serial_base_ctrl_release,
122 port->ctrl_id, 0);
123 if (err)
124 goto err_put_device;
125
126 err = device_add(&ctrl_dev->dev);
127 if (err)
128 goto err_put_device;
129
130 return ctrl_dev;
131
132err_put_device:
133 put_device(&ctrl_dev->dev);
134
135 return ERR_PTR(err);
136}
137
138static void serial_base_port_release(struct device *dev)
139{
140 struct serial_port_device *port_dev = to_serial_base_port_device(dev);
141
142 kfree(port_dev);
143}
144
145struct serial_port_device *serial_base_port_add(struct uart_port *port,
146 struct serial_ctrl_device *ctrl_dev)
147{
148 struct serial_port_device *port_dev;
149 int min = 0, max = -1; /* Use -1 for max to apply IDA defaults */
150 int err;
151
152 port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL);
153 if (!port_dev)
154 return ERR_PTR(-ENOMEM);
155
156 /* Device driver specified port_id vs automatic assignment? */
157 if (port->port_id) {
158 min = port->port_id;
159 max = port->port_id;
160 }
161
162 err = ida_alloc_range(&ctrl_dev->port_ida, min, max, GFP_KERNEL);
163 if (err < 0) {
164 kfree(port_dev);
165 return ERR_PTR(err);
166 }
167
168 port->port_id = err;
169
170 err = serial_base_device_init(port, &port_dev->dev,
171 &ctrl_dev->dev, &serial_port_type,
172 serial_base_port_release,
173 port->ctrl_id, port->port_id);
174 if (err)
175 goto err_put_device;
176
177 port_dev->port = port;
178
179 err = device_add(&port_dev->dev);
180 if (err)
181 goto err_put_device;
182
183 return port_dev;
184
185err_put_device:
186 put_device(&port_dev->dev);
187 ida_free(&ctrl_dev->port_ida, port->port_id);
188
189 return ERR_PTR(err);
190}
191
192void serial_base_port_device_remove(struct serial_port_device *port_dev)
193{
194 struct serial_ctrl_device *ctrl_dev;
195 struct device *parent;
196
197 if (!port_dev)
198 return;
199
200 parent = port_dev->dev.parent;
201 ctrl_dev = to_serial_base_ctrl_device(parent);
202
203 device_del(&port_dev->dev);
204 ida_free(&ctrl_dev->port_ida, port_dev->port->port_id);
205 put_device(&port_dev->dev);
206}
207
208#ifdef CONFIG_SERIAL_CORE_CONSOLE
209
210/**
211 * serial_base_match_and_update_preferred_console - Match and update a preferred console
212 * @drv: Serial port device driver
213 * @port: Serial port instance
214 *
215 * Tries to match and update the preferred console for a serial port for
216 * the kernel command line option console=DEVNAME:0.0.
217 *
218 * Cannot be called early for ISA ports, depends on struct device.
219 *
220 * Return: 0 on success, negative error code on failure.
221 */
222int serial_base_match_and_update_preferred_console(struct uart_driver *drv,
223 struct uart_port *port)
224{
225 const char *port_match __free(kfree) = NULL;
226 int ret;
227
228 port_match = kasprintf(GFP_KERNEL, "%s:%d.%d", dev_name(port->dev),
229 port->ctrl_id, port->port_id);
230 if (!port_match)
231 return -ENOMEM;
232
233 ret = match_devname_and_update_preferred_console(port_match,
234 drv->dev_name,
235 port->line);
236 if (ret == -ENOENT)
237 return 0;
238
239 return ret;
240}
241
242#endif
243
244static int serial_base_init(void)
245{
246 int ret;
247
248 ret = bus_register(&serial_base_bus_type);
249 if (ret)
250 return ret;
251
252 ret = serial_base_ctrl_init();
253 if (ret)
254 goto err_bus_unregister;
255
256 ret = serial_base_port_init();
257 if (ret)
258 goto err_ctrl_exit;
259
260 serial_base_initialized = true;
261
262 return 0;
263
264err_ctrl_exit:
265 serial_base_ctrl_exit();
266
267err_bus_unregister:
268 bus_unregister(&serial_base_bus_type);
269
270 return ret;
271}
272arch_initcall(serial_base_init);
273
274static void serial_base_exit(void)
275{
276 serial_base_port_exit();
277 serial_base_ctrl_exit();
278 bus_unregister(&serial_base_bus_type);
279}
280module_exit(serial_base_exit);
281
282MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
283MODULE_DESCRIPTION("Serial core bus");
284MODULE_LICENSE("GPL");
1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Serial base bus layer for controllers
4 *
5 * Copyright (C) 2023 Texas Instruments Incorporated - https://www.ti.com/
6 * Author: Tony Lindgren <tony@atomide.com>
7 *
8 * The serial core bus manages the serial core controller instances.
9 */
10
11#include <linux/container_of.h>
12#include <linux/device.h>
13#include <linux/idr.h>
14#include <linux/module.h>
15#include <linux/serial_core.h>
16#include <linux/slab.h>
17#include <linux/spinlock.h>
18
19#include "serial_base.h"
20
21static bool serial_base_initialized;
22
23static const struct device_type serial_ctrl_type = {
24 .name = "ctrl",
25};
26
27static const struct device_type serial_port_type = {
28 .name = "port",
29};
30
31static int serial_base_match(struct device *dev, struct device_driver *drv)
32{
33 if (dev->type == &serial_ctrl_type &&
34 str_has_prefix(drv->name, serial_ctrl_type.name))
35 return 1;
36
37 if (dev->type == &serial_port_type &&
38 str_has_prefix(drv->name, serial_port_type.name))
39 return 1;
40
41 return 0;
42}
43
44static struct bus_type serial_base_bus_type = {
45 .name = "serial-base",
46 .match = serial_base_match,
47};
48
49int serial_base_driver_register(struct device_driver *driver)
50{
51 driver->bus = &serial_base_bus_type;
52
53 return driver_register(driver);
54}
55
56void serial_base_driver_unregister(struct device_driver *driver)
57{
58 driver_unregister(driver);
59}
60
61static int serial_base_device_init(struct uart_port *port,
62 struct device *dev,
63 struct device *parent_dev,
64 const struct device_type *type,
65 void (*release)(struct device *dev),
66 unsigned int ctrl_id,
67 unsigned int port_id)
68{
69 device_initialize(dev);
70 dev->type = type;
71 dev->parent = parent_dev;
72 dev->bus = &serial_base_bus_type;
73 dev->release = release;
74
75 if (!serial_base_initialized) {
76 dev_dbg(port->dev, "uart_add_one_port() called before arch_initcall()?\n");
77 return -EPROBE_DEFER;
78 }
79
80 if (type == &serial_ctrl_type)
81 return dev_set_name(dev, "%s:%d", dev_name(port->dev), ctrl_id);
82
83 if (type == &serial_port_type)
84 return dev_set_name(dev, "%s:%d.%d", dev_name(port->dev),
85 ctrl_id, port_id);
86
87 return -EINVAL;
88}
89
90static void serial_base_ctrl_release(struct device *dev)
91{
92 struct serial_ctrl_device *ctrl_dev = to_serial_base_ctrl_device(dev);
93
94 kfree(ctrl_dev);
95}
96
97void serial_base_ctrl_device_remove(struct serial_ctrl_device *ctrl_dev)
98{
99 if (!ctrl_dev)
100 return;
101
102 device_del(&ctrl_dev->dev);
103 put_device(&ctrl_dev->dev);
104}
105
106struct serial_ctrl_device *serial_base_ctrl_add(struct uart_port *port,
107 struct device *parent)
108{
109 struct serial_ctrl_device *ctrl_dev;
110 int err;
111
112 ctrl_dev = kzalloc(sizeof(*ctrl_dev), GFP_KERNEL);
113 if (!ctrl_dev)
114 return ERR_PTR(-ENOMEM);
115
116 ida_init(&ctrl_dev->port_ida);
117
118 err = serial_base_device_init(port, &ctrl_dev->dev,
119 parent, &serial_ctrl_type,
120 serial_base_ctrl_release,
121 port->ctrl_id, 0);
122 if (err)
123 goto err_put_device;
124
125 err = device_add(&ctrl_dev->dev);
126 if (err)
127 goto err_put_device;
128
129 return ctrl_dev;
130
131err_put_device:
132 put_device(&ctrl_dev->dev);
133
134 return ERR_PTR(err);
135}
136
137static void serial_base_port_release(struct device *dev)
138{
139 struct serial_port_device *port_dev = to_serial_base_port_device(dev);
140
141 kfree(port_dev);
142}
143
144struct serial_port_device *serial_base_port_add(struct uart_port *port,
145 struct serial_ctrl_device *ctrl_dev)
146{
147 struct serial_port_device *port_dev;
148 int min = 0, max = -1; /* Use -1 for max to apply IDA defaults */
149 int err;
150
151 port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL);
152 if (!port_dev)
153 return ERR_PTR(-ENOMEM);
154
155 /* Device driver specified port_id vs automatic assignment? */
156 if (port->port_id) {
157 min = port->port_id;
158 max = port->port_id;
159 }
160
161 err = ida_alloc_range(&ctrl_dev->port_ida, min, max, GFP_KERNEL);
162 if (err < 0) {
163 kfree(port_dev);
164 return ERR_PTR(err);
165 }
166
167 port->port_id = err;
168
169 err = serial_base_device_init(port, &port_dev->dev,
170 &ctrl_dev->dev, &serial_port_type,
171 serial_base_port_release,
172 port->ctrl_id, port->port_id);
173 if (err)
174 goto err_put_device;
175
176 port_dev->port = port;
177
178 err = device_add(&port_dev->dev);
179 if (err)
180 goto err_put_device;
181
182 return port_dev;
183
184err_put_device:
185 put_device(&port_dev->dev);
186 ida_free(&ctrl_dev->port_ida, port->port_id);
187
188 return ERR_PTR(err);
189}
190
191void serial_base_port_device_remove(struct serial_port_device *port_dev)
192{
193 struct serial_ctrl_device *ctrl_dev;
194 struct device *parent;
195
196 if (!port_dev)
197 return;
198
199 parent = port_dev->dev.parent;
200 ctrl_dev = to_serial_base_ctrl_device(parent);
201
202 device_del(&port_dev->dev);
203 ida_free(&ctrl_dev->port_ida, port_dev->port->port_id);
204 put_device(&port_dev->dev);
205}
206
207static int serial_base_init(void)
208{
209 int ret;
210
211 ret = bus_register(&serial_base_bus_type);
212 if (ret)
213 return ret;
214
215 ret = serial_base_ctrl_init();
216 if (ret)
217 goto err_bus_unregister;
218
219 ret = serial_base_port_init();
220 if (ret)
221 goto err_ctrl_exit;
222
223 serial_base_initialized = true;
224
225 return 0;
226
227err_ctrl_exit:
228 serial_base_ctrl_exit();
229
230err_bus_unregister:
231 bus_unregister(&serial_base_bus_type);
232
233 return ret;
234}
235arch_initcall(serial_base_init);
236
237static void serial_base_exit(void)
238{
239 serial_base_port_exit();
240 serial_base_ctrl_exit();
241 bus_unregister(&serial_base_bus_type);
242}
243module_exit(serial_base_exit);
244
245MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
246MODULE_DESCRIPTION("Serial core bus");
247MODULE_LICENSE("GPL");