1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * System Control and Management Interface (SCMI) Message Protocol bus layer
4 *
5 * Copyright (C) 2018-2021 ARM Ltd.
6 */
7
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9
10 #include <linux/types.h>
11 #include <linux/module.h>
12 #include <linux/kernel.h>
13 #include <linux/slab.h>
14 #include <linux/device.h>
15
16 #include "common.h"
17
18 static DEFINE_IDA(scmi_bus_id);
19 static DEFINE_IDR(scmi_protocols);
20 static DEFINE_SPINLOCK(protocol_lock);
21
22 static const struct scmi_device_id *
scmi_dev_match_id(struct scmi_device * scmi_dev,struct scmi_driver * scmi_drv)23 scmi_dev_match_id(struct scmi_device *scmi_dev, struct scmi_driver *scmi_drv)
24 {
25 const struct scmi_device_id *id = scmi_drv->id_table;
26
27 if (!id)
28 return NULL;
29
30 for (; id->protocol_id; id++)
31 if (id->protocol_id == scmi_dev->protocol_id) {
32 if (!id->name)
33 return id;
34 else if (!strcmp(id->name, scmi_dev->name))
35 return id;
36 }
37
38 return NULL;
39 }
40
scmi_dev_match(struct device * dev,struct device_driver * drv)41 static int scmi_dev_match(struct device *dev, struct device_driver *drv)
42 {
43 struct scmi_driver *scmi_drv = to_scmi_driver(drv);
44 struct scmi_device *scmi_dev = to_scmi_dev(dev);
45 const struct scmi_device_id *id;
46
47 id = scmi_dev_match_id(scmi_dev, scmi_drv);
48 if (id)
49 return 1;
50
51 return 0;
52 }
53
scmi_match_by_id_table(struct device * dev,void * data)54 static int scmi_match_by_id_table(struct device *dev, void *data)
55 {
56 struct scmi_device *sdev = to_scmi_dev(dev);
57 struct scmi_device_id *id_table = data;
58
59 return sdev->protocol_id == id_table->protocol_id &&
60 !strcmp(sdev->name, id_table->name);
61 }
62
scmi_child_dev_find(struct device * parent,int prot_id,const char * name)63 struct scmi_device *scmi_child_dev_find(struct device *parent,
64 int prot_id, const char *name)
65 {
66 struct scmi_device_id id_table;
67 struct device *dev;
68
69 id_table.protocol_id = prot_id;
70 id_table.name = name;
71
72 dev = device_find_child(parent, &id_table, scmi_match_by_id_table);
73 if (!dev)
74 return NULL;
75
76 return to_scmi_dev(dev);
77 }
78
scmi_protocol_get(int protocol_id)79 const struct scmi_protocol *scmi_protocol_get(int protocol_id)
80 {
81 const struct scmi_protocol *proto;
82
83 proto = idr_find(&scmi_protocols, protocol_id);
84 if (!proto || !try_module_get(proto->owner)) {
85 pr_warn("SCMI Protocol 0x%x not found!\n", protocol_id);
86 return NULL;
87 }
88
89 pr_debug("Found SCMI Protocol 0x%x\n", protocol_id);
90
91 return proto;
92 }
93
scmi_protocol_put(int protocol_id)94 void scmi_protocol_put(int protocol_id)
95 {
96 const struct scmi_protocol *proto;
97
98 proto = idr_find(&scmi_protocols, protocol_id);
99 if (proto)
100 module_put(proto->owner);
101 }
102
scmi_dev_probe(struct device * dev)103 static int scmi_dev_probe(struct device *dev)
104 {
105 struct scmi_driver *scmi_drv = to_scmi_driver(dev->driver);
106 struct scmi_device *scmi_dev = to_scmi_dev(dev);
107 const struct scmi_device_id *id;
108
109 id = scmi_dev_match_id(scmi_dev, scmi_drv);
110 if (!id)
111 return -ENODEV;
112
113 if (!scmi_dev->handle)
114 return -EPROBE_DEFER;
115
116 return scmi_drv->probe(scmi_dev);
117 }
118
scmi_dev_remove(struct device * dev)119 static int scmi_dev_remove(struct device *dev)
120 {
121 struct scmi_driver *scmi_drv = to_scmi_driver(dev->driver);
122 struct scmi_device *scmi_dev = to_scmi_dev(dev);
123
124 if (scmi_drv->remove)
125 scmi_drv->remove(scmi_dev);
126
127 return 0;
128 }
129
130 static struct bus_type scmi_bus_type = {
131 .name = "scmi_protocol",
132 .match = scmi_dev_match,
133 .probe = scmi_dev_probe,
134 .remove = scmi_dev_remove,
135 };
136
scmi_driver_register(struct scmi_driver * driver,struct module * owner,const char * mod_name)137 int scmi_driver_register(struct scmi_driver *driver, struct module *owner,
138 const char *mod_name)
139 {
140 int retval;
141
142 retval = scmi_protocol_device_request(driver->id_table);
143 if (retval)
144 return retval;
145
146 driver->driver.bus = &scmi_bus_type;
147 driver->driver.name = driver->name;
148 driver->driver.owner = owner;
149 driver->driver.mod_name = mod_name;
150
151 retval = driver_register(&driver->driver);
152 if (!retval)
153 pr_debug("registered new scmi driver %s\n", driver->name);
154
155 return retval;
156 }
157 EXPORT_SYMBOL_GPL(scmi_driver_register);
158
scmi_driver_unregister(struct scmi_driver * driver)159 void scmi_driver_unregister(struct scmi_driver *driver)
160 {
161 driver_unregister(&driver->driver);
162 scmi_protocol_device_unrequest(driver->id_table);
163 }
164 EXPORT_SYMBOL_GPL(scmi_driver_unregister);
165
scmi_device_release(struct device * dev)166 static void scmi_device_release(struct device *dev)
167 {
168 kfree(to_scmi_dev(dev));
169 }
170
171 struct scmi_device *
scmi_device_create(struct device_node * np,struct device * parent,int protocol,const char * name)172 scmi_device_create(struct device_node *np, struct device *parent, int protocol,
173 const char *name)
174 {
175 int id, retval;
176 struct scmi_device *scmi_dev;
177
178 scmi_dev = kzalloc(sizeof(*scmi_dev), GFP_KERNEL);
179 if (!scmi_dev)
180 return NULL;
181
182 scmi_dev->name = kstrdup_const(name ?: "unknown", GFP_KERNEL);
183 if (!scmi_dev->name) {
184 kfree(scmi_dev);
185 return NULL;
186 }
187
188 id = ida_simple_get(&scmi_bus_id, 1, 0, GFP_KERNEL);
189 if (id < 0) {
190 kfree_const(scmi_dev->name);
191 kfree(scmi_dev);
192 return NULL;
193 }
194
195 scmi_dev->id = id;
196 scmi_dev->protocol_id = protocol;
197 scmi_dev->dev.parent = parent;
198 scmi_dev->dev.of_node = np;
199 scmi_dev->dev.bus = &scmi_bus_type;
200 scmi_dev->dev.release = scmi_device_release;
201 dev_set_name(&scmi_dev->dev, "scmi_dev.%d", id);
202
203 retval = device_register(&scmi_dev->dev);
204 if (retval)
205 goto put_dev;
206
207 return scmi_dev;
208 put_dev:
209 kfree_const(scmi_dev->name);
210 put_device(&scmi_dev->dev);
211 ida_simple_remove(&scmi_bus_id, id);
212 return NULL;
213 }
214
scmi_device_destroy(struct scmi_device * scmi_dev)215 void scmi_device_destroy(struct scmi_device *scmi_dev)
216 {
217 kfree_const(scmi_dev->name);
218 scmi_handle_put(scmi_dev->handle);
219 ida_simple_remove(&scmi_bus_id, scmi_dev->id);
220 device_unregister(&scmi_dev->dev);
221 }
222
scmi_set_handle(struct scmi_device * scmi_dev)223 void scmi_set_handle(struct scmi_device *scmi_dev)
224 {
225 scmi_dev->handle = scmi_handle_get(&scmi_dev->dev);
226 }
227
scmi_protocol_register(const struct scmi_protocol * proto)228 int scmi_protocol_register(const struct scmi_protocol *proto)
229 {
230 int ret;
231
232 if (!proto) {
233 pr_err("invalid protocol\n");
234 return -EINVAL;
235 }
236
237 if (!proto->instance_init) {
238 pr_err("missing init for protocol 0x%x\n", proto->id);
239 return -EINVAL;
240 }
241
242 spin_lock(&protocol_lock);
243 ret = idr_alloc(&scmi_protocols, (void *)proto,
244 proto->id, proto->id + 1, GFP_ATOMIC);
245 spin_unlock(&protocol_lock);
246 if (ret != proto->id) {
247 pr_err("unable to allocate SCMI idr slot for 0x%x - err %d\n",
248 proto->id, ret);
249 return ret;
250 }
251
252 pr_debug("Registered SCMI Protocol 0x%x\n", proto->id);
253
254 return 0;
255 }
256 EXPORT_SYMBOL_GPL(scmi_protocol_register);
257
scmi_protocol_unregister(const struct scmi_protocol * proto)258 void scmi_protocol_unregister(const struct scmi_protocol *proto)
259 {
260 spin_lock(&protocol_lock);
261 idr_remove(&scmi_protocols, proto->id);
262 spin_unlock(&protocol_lock);
263
264 pr_debug("Unregistered SCMI Protocol 0x%x\n", proto->id);
265
266 return;
267 }
268 EXPORT_SYMBOL_GPL(scmi_protocol_unregister);
269
__scmi_devices_unregister(struct device * dev,void * data)270 static int __scmi_devices_unregister(struct device *dev, void *data)
271 {
272 struct scmi_device *scmi_dev = to_scmi_dev(dev);
273
274 scmi_device_destroy(scmi_dev);
275 return 0;
276 }
277
scmi_devices_unregister(void)278 static void scmi_devices_unregister(void)
279 {
280 bus_for_each_dev(&scmi_bus_type, NULL, NULL, __scmi_devices_unregister);
281 }
282
scmi_bus_init(void)283 int __init scmi_bus_init(void)
284 {
285 int retval;
286
287 retval = bus_register(&scmi_bus_type);
288 if (retval)
289 pr_err("scmi protocol bus register failed (%d)\n", retval);
290
291 return retval;
292 }
293
scmi_bus_exit(void)294 void __exit scmi_bus_exit(void)
295 {
296 scmi_devices_unregister();
297 bus_unregister(&scmi_bus_type);
298 ida_destroy(&scmi_bus_id);
299 }
300