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 
21 static bool serial_base_initialized;
22 
23 static const struct device_type serial_ctrl_type = {
24 	.name = "ctrl",
25 };
26 
27 static const struct device_type serial_port_type = {
28 	.name = "port",
29 };
30 
serial_base_match(struct device * dev,struct device_driver * drv)31 static 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 
44 static struct bus_type serial_base_bus_type = {
45 	.name = "serial-base",
46 	.match = serial_base_match,
47 };
48 
serial_base_driver_register(struct device_driver * driver)49 int serial_base_driver_register(struct device_driver *driver)
50 {
51 	driver->bus = &serial_base_bus_type;
52 
53 	return driver_register(driver);
54 }
55 
serial_base_driver_unregister(struct device_driver * driver)56 void serial_base_driver_unregister(struct device_driver *driver)
57 {
58 	driver_unregister(driver);
59 }
60 
serial_base_device_init(struct uart_port * port,struct device * dev,struct device * parent_dev,const struct device_type * type,void (* release)(struct device * dev),unsigned int ctrl_id,unsigned int port_id)61 static 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 
serial_base_ctrl_release(struct device * dev)90 static 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 
serial_base_ctrl_device_remove(struct serial_ctrl_device * ctrl_dev)97 void 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 
serial_base_ctrl_add(struct uart_port * port,struct device * parent)106 struct 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 
131 err_put_device:
132 	put_device(&ctrl_dev->dev);
133 
134 	return ERR_PTR(err);
135 }
136 
serial_base_port_release(struct device * dev)137 static 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 
serial_base_port_add(struct uart_port * port,struct serial_ctrl_device * ctrl_dev)144 struct 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 
184 err_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 
serial_base_port_device_remove(struct serial_port_device * port_dev)191 void 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 
serial_base_init(void)207 static 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 
227 err_ctrl_exit:
228 	serial_base_ctrl_exit();
229 
230 err_bus_unregister:
231 	bus_unregister(&serial_base_bus_type);
232 
233 	return ret;
234 }
235 arch_initcall(serial_base_init);
236 
serial_base_exit(void)237 static void serial_base_exit(void)
238 {
239 	serial_base_port_exit();
240 	serial_base_ctrl_exit();
241 	bus_unregister(&serial_base_bus_type);
242 }
243 module_exit(serial_base_exit);
244 
245 MODULE_AUTHOR("Tony Lindgren <tony@atomide.com>");
246 MODULE_DESCRIPTION("Serial core bus");
247 MODULE_LICENSE("GPL");
248