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/atomic.h>
11 #include <linux/types.h>
12 #include <linux/module.h>
13 #include <linux/of.h>
14 #include <linux/kernel.h>
15 #include <linux/slab.h>
16 #include <linux/device.h>
17
18 #include "common.h"
19
20 BLOCKING_NOTIFIER_HEAD(scmi_requested_devices_nh);
21 EXPORT_SYMBOL_GPL(scmi_requested_devices_nh);
22
23 static DEFINE_IDA(scmi_bus_id);
24
25 static DEFINE_IDR(scmi_requested_devices);
26 /* Protect access to scmi_requested_devices */
27 static DEFINE_MUTEX(scmi_requested_devices_mtx);
28
29 struct scmi_requested_dev {
30 const struct scmi_device_id *id_table;
31 struct list_head node;
32 };
33
34 /* Track globally the creation of SCMI SystemPower related devices */
35 static atomic_t scmi_syspower_registered = ATOMIC_INIT(0);
36
37 /**
38 * scmi_protocol_device_request - Helper to request a device
39 *
40 * @id_table: A protocol/name pair descriptor for the device to be created.
41 *
42 * This helper let an SCMI driver request specific devices identified by the
43 * @id_table to be created for each active SCMI instance.
44 *
45 * The requested device name MUST NOT be already existent for any protocol;
46 * at first the freshly requested @id_table is annotated in the IDR table
47 * @scmi_requested_devices and then the requested device is advertised to any
48 * registered party via the @scmi_requested_devices_nh notification chain.
49 *
50 * Return: 0 on Success
51 */
scmi_protocol_device_request(const struct scmi_device_id * id_table)52 static int scmi_protocol_device_request(const struct scmi_device_id *id_table)
53 {
54 int ret = 0;
55 unsigned int id = 0;
56 struct list_head *head, *phead = NULL;
57 struct scmi_requested_dev *rdev;
58
59 pr_debug("Requesting SCMI device (%s) for protocol %x\n",
60 id_table->name, id_table->protocol_id);
61
62 if (IS_ENABLED(CONFIG_ARM_SCMI_RAW_MODE_SUPPORT) &&
63 !IS_ENABLED(CONFIG_ARM_SCMI_RAW_MODE_SUPPORT_COEX)) {
64 pr_warn("SCMI Raw mode active. Rejecting '%s'/0x%02X\n",
65 id_table->name, id_table->protocol_id);
66 return -EINVAL;
67 }
68
69 /*
70 * Search for the matching protocol rdev list and then search
71 * of any existent equally named device...fails if any duplicate found.
72 */
73 mutex_lock(&scmi_requested_devices_mtx);
74 idr_for_each_entry(&scmi_requested_devices, head, id) {
75 if (!phead) {
76 /* A list found registered in the IDR is never empty */
77 rdev = list_first_entry(head, struct scmi_requested_dev,
78 node);
79 if (rdev->id_table->protocol_id ==
80 id_table->protocol_id)
81 phead = head;
82 }
83 list_for_each_entry(rdev, head, node) {
84 if (!strcmp(rdev->id_table->name, id_table->name)) {
85 pr_err("Ignoring duplicate request [%d] %s\n",
86 rdev->id_table->protocol_id,
87 rdev->id_table->name);
88 ret = -EINVAL;
89 goto out;
90 }
91 }
92 }
93
94 /*
95 * No duplicate found for requested id_table, so let's create a new
96 * requested device entry for this new valid request.
97 */
98 rdev = kzalloc(sizeof(*rdev), GFP_KERNEL);
99 if (!rdev) {
100 ret = -ENOMEM;
101 goto out;
102 }
103 rdev->id_table = id_table;
104
105 /*
106 * Append the new requested device table descriptor to the head of the
107 * related protocol list, eventually creating such head if not already
108 * there.
109 */
110 if (!phead) {
111 phead = kzalloc(sizeof(*phead), GFP_KERNEL);
112 if (!phead) {
113 kfree(rdev);
114 ret = -ENOMEM;
115 goto out;
116 }
117 INIT_LIST_HEAD(phead);
118
119 ret = idr_alloc(&scmi_requested_devices, (void *)phead,
120 id_table->protocol_id,
121 id_table->protocol_id + 1, GFP_KERNEL);
122 if (ret != id_table->protocol_id) {
123 pr_err("Failed to save SCMI device - ret:%d\n", ret);
124 kfree(rdev);
125 kfree(phead);
126 ret = -EINVAL;
127 goto out;
128 }
129 ret = 0;
130 }
131 list_add(&rdev->node, phead);
132
133 out:
134 mutex_unlock(&scmi_requested_devices_mtx);
135
136 if (!ret)
137 blocking_notifier_call_chain(&scmi_requested_devices_nh,
138 SCMI_BUS_NOTIFY_DEVICE_REQUEST,
139 (void *)rdev->id_table);
140
141 return ret;
142 }
143
144 /**
145 * scmi_protocol_device_unrequest - Helper to unrequest a device
146 *
147 * @id_table: A protocol/name pair descriptor for the device to be unrequested.
148 *
149 * The unrequested device, described by the provided id_table, is at first
150 * removed from the IDR @scmi_requested_devices and then the removal is
151 * advertised to any registered party via the @scmi_requested_devices_nh
152 * notification chain.
153 */
scmi_protocol_device_unrequest(const struct scmi_device_id * id_table)154 static void scmi_protocol_device_unrequest(const struct scmi_device_id *id_table)
155 {
156 struct list_head *phead;
157
158 pr_debug("Unrequesting SCMI device (%s) for protocol %x\n",
159 id_table->name, id_table->protocol_id);
160
161 mutex_lock(&scmi_requested_devices_mtx);
162 phead = idr_find(&scmi_requested_devices, id_table->protocol_id);
163 if (phead) {
164 struct scmi_requested_dev *victim, *tmp;
165
166 list_for_each_entry_safe(victim, tmp, phead, node) {
167 if (!strcmp(victim->id_table->name, id_table->name)) {
168 list_del(&victim->node);
169
170 mutex_unlock(&scmi_requested_devices_mtx);
171 blocking_notifier_call_chain(&scmi_requested_devices_nh,
172 SCMI_BUS_NOTIFY_DEVICE_UNREQUEST,
173 (void *)victim->id_table);
174 kfree(victim);
175 mutex_lock(&scmi_requested_devices_mtx);
176 break;
177 }
178 }
179
180 if (list_empty(phead)) {
181 idr_remove(&scmi_requested_devices,
182 id_table->protocol_id);
183 kfree(phead);
184 }
185 }
186 mutex_unlock(&scmi_requested_devices_mtx);
187 }
188
189 static const struct scmi_device_id *
scmi_dev_match_id(struct scmi_device * scmi_dev,struct scmi_driver * scmi_drv)190 scmi_dev_match_id(struct scmi_device *scmi_dev, struct scmi_driver *scmi_drv)
191 {
192 const struct scmi_device_id *id = scmi_drv->id_table;
193
194 if (!id)
195 return NULL;
196
197 for (; id->protocol_id; id++)
198 if (id->protocol_id == scmi_dev->protocol_id) {
199 if (!id->name)
200 return id;
201 else if (!strcmp(id->name, scmi_dev->name))
202 return id;
203 }
204
205 return NULL;
206 }
207
scmi_dev_match(struct device * dev,struct device_driver * drv)208 static int scmi_dev_match(struct device *dev, struct device_driver *drv)
209 {
210 struct scmi_driver *scmi_drv = to_scmi_driver(drv);
211 struct scmi_device *scmi_dev = to_scmi_dev(dev);
212 const struct scmi_device_id *id;
213
214 id = scmi_dev_match_id(scmi_dev, scmi_drv);
215 if (id)
216 return 1;
217
218 return 0;
219 }
220
scmi_match_by_id_table(struct device * dev,void * data)221 static int scmi_match_by_id_table(struct device *dev, void *data)
222 {
223 struct scmi_device *sdev = to_scmi_dev(dev);
224 struct scmi_device_id *id_table = data;
225
226 return sdev->protocol_id == id_table->protocol_id &&
227 (id_table->name && !strcmp(sdev->name, id_table->name));
228 }
229
scmi_child_dev_find(struct device * parent,int prot_id,const char * name)230 static struct scmi_device *scmi_child_dev_find(struct device *parent,
231 int prot_id, const char *name)
232 {
233 struct scmi_device_id id_table;
234 struct device *dev;
235
236 id_table.protocol_id = prot_id;
237 id_table.name = name;
238
239 dev = device_find_child(parent, &id_table, scmi_match_by_id_table);
240 if (!dev)
241 return NULL;
242
243 return to_scmi_dev(dev);
244 }
245
scmi_dev_probe(struct device * dev)246 static int scmi_dev_probe(struct device *dev)
247 {
248 struct scmi_driver *scmi_drv = to_scmi_driver(dev->driver);
249 struct scmi_device *scmi_dev = to_scmi_dev(dev);
250
251 if (!scmi_dev->handle)
252 return -EPROBE_DEFER;
253
254 return scmi_drv->probe(scmi_dev);
255 }
256
scmi_dev_remove(struct device * dev)257 static void scmi_dev_remove(struct device *dev)
258 {
259 struct scmi_driver *scmi_drv = to_scmi_driver(dev->driver);
260 struct scmi_device *scmi_dev = to_scmi_dev(dev);
261
262 if (scmi_drv->remove)
263 scmi_drv->remove(scmi_dev);
264 }
265
266 struct bus_type scmi_bus_type = {
267 .name = "scmi_protocol",
268 .match = scmi_dev_match,
269 .probe = scmi_dev_probe,
270 .remove = scmi_dev_remove,
271 };
272 EXPORT_SYMBOL_GPL(scmi_bus_type);
273
scmi_driver_register(struct scmi_driver * driver,struct module * owner,const char * mod_name)274 int scmi_driver_register(struct scmi_driver *driver, struct module *owner,
275 const char *mod_name)
276 {
277 int retval;
278
279 if (!driver->probe)
280 return -EINVAL;
281
282 retval = scmi_protocol_device_request(driver->id_table);
283 if (retval)
284 return retval;
285
286 driver->driver.bus = &scmi_bus_type;
287 driver->driver.name = driver->name;
288 driver->driver.owner = owner;
289 driver->driver.mod_name = mod_name;
290
291 retval = driver_register(&driver->driver);
292 if (!retval)
293 pr_debug("Registered new scmi driver %s\n", driver->name);
294
295 return retval;
296 }
297 EXPORT_SYMBOL_GPL(scmi_driver_register);
298
scmi_driver_unregister(struct scmi_driver * driver)299 void scmi_driver_unregister(struct scmi_driver *driver)
300 {
301 driver_unregister(&driver->driver);
302 scmi_protocol_device_unrequest(driver->id_table);
303 }
304 EXPORT_SYMBOL_GPL(scmi_driver_unregister);
305
scmi_device_release(struct device * dev)306 static void scmi_device_release(struct device *dev)
307 {
308 kfree(to_scmi_dev(dev));
309 }
310
__scmi_device_destroy(struct scmi_device * scmi_dev)311 static void __scmi_device_destroy(struct scmi_device *scmi_dev)
312 {
313 pr_debug("(%s) Destroying SCMI device '%s' for protocol 0x%x (%s)\n",
314 of_node_full_name(scmi_dev->dev.parent->of_node),
315 dev_name(&scmi_dev->dev), scmi_dev->protocol_id,
316 scmi_dev->name);
317
318 if (scmi_dev->protocol_id == SCMI_PROTOCOL_SYSTEM)
319 atomic_set(&scmi_syspower_registered, 0);
320
321 kfree_const(scmi_dev->name);
322 ida_free(&scmi_bus_id, scmi_dev->id);
323 device_unregister(&scmi_dev->dev);
324 }
325
326 static struct scmi_device *
__scmi_device_create(struct device_node * np,struct device * parent,int protocol,const char * name)327 __scmi_device_create(struct device_node *np, struct device *parent,
328 int protocol, const char *name)
329 {
330 int id, retval;
331 struct scmi_device *scmi_dev;
332
333 /*
334 * If the same protocol/name device already exist under the same parent
335 * (i.e. SCMI instance) just return the existent device.
336 * This avoids any race between the SCMI driver, creating devices for
337 * each DT defined protocol at probe time, and the concurrent
338 * registration of SCMI drivers.
339 */
340 scmi_dev = scmi_child_dev_find(parent, protocol, name);
341 if (scmi_dev)
342 return scmi_dev;
343
344 /*
345 * Ignore any possible subsequent failures while creating the device
346 * since we are doomed anyway at that point; not using a mutex which
347 * spans across this whole function to keep things simple and to avoid
348 * to serialize all the __scmi_device_create calls across possibly
349 * different SCMI server instances (parent)
350 */
351 if (protocol == SCMI_PROTOCOL_SYSTEM &&
352 atomic_cmpxchg(&scmi_syspower_registered, 0, 1)) {
353 dev_warn(parent,
354 "SCMI SystemPower protocol device must be unique !\n");
355 return NULL;
356 }
357
358 scmi_dev = kzalloc(sizeof(*scmi_dev), GFP_KERNEL);
359 if (!scmi_dev)
360 return NULL;
361
362 scmi_dev->name = kstrdup_const(name ?: "unknown", GFP_KERNEL);
363 if (!scmi_dev->name) {
364 kfree(scmi_dev);
365 return NULL;
366 }
367
368 id = ida_alloc_min(&scmi_bus_id, 1, GFP_KERNEL);
369 if (id < 0) {
370 kfree_const(scmi_dev->name);
371 kfree(scmi_dev);
372 return NULL;
373 }
374
375 scmi_dev->id = id;
376 scmi_dev->protocol_id = protocol;
377 scmi_dev->dev.parent = parent;
378 device_set_node(&scmi_dev->dev, of_fwnode_handle(np));
379 scmi_dev->dev.bus = &scmi_bus_type;
380 scmi_dev->dev.release = scmi_device_release;
381 dev_set_name(&scmi_dev->dev, "scmi_dev.%d", id);
382
383 retval = device_register(&scmi_dev->dev);
384 if (retval)
385 goto put_dev;
386
387 pr_debug("(%s) Created SCMI device '%s' for protocol 0x%x (%s)\n",
388 of_node_full_name(parent->of_node),
389 dev_name(&scmi_dev->dev), protocol, name);
390
391 return scmi_dev;
392 put_dev:
393 kfree_const(scmi_dev->name);
394 put_device(&scmi_dev->dev);
395 ida_free(&scmi_bus_id, id);
396 return NULL;
397 }
398
399 /**
400 * scmi_device_create - A method to create one or more SCMI devices
401 *
402 * @np: A reference to the device node to use for the new device(s)
403 * @parent: The parent device to use identifying a specific SCMI instance
404 * @protocol: The SCMI protocol to be associated with this device
405 * @name: The requested-name of the device to be created; this is optional
406 * and if no @name is provided, all the devices currently known to
407 * be requested on the SCMI bus for @protocol will be created.
408 *
409 * This method can be invoked to create a single well-defined device (like
410 * a transport device or a device requested by an SCMI driver loaded after
411 * the core SCMI stack has been probed), or to create all the devices currently
412 * known to have been requested by the loaded SCMI drivers for a specific
413 * protocol (typically during SCMI core protocol enumeration at probe time).
414 *
415 * Return: The created device (or one of them if @name was NOT provided and
416 * multiple devices were created) or NULL if no device was created;
417 * note that NULL indicates an error ONLY in case a specific @name
418 * was provided: when @name param was not provided, a number of devices
419 * could have been potentially created for a whole protocol, unless no
420 * device was found to have been requested for that specific protocol.
421 */
scmi_device_create(struct device_node * np,struct device * parent,int protocol,const char * name)422 struct scmi_device *scmi_device_create(struct device_node *np,
423 struct device *parent, int protocol,
424 const char *name)
425 {
426 struct list_head *phead;
427 struct scmi_requested_dev *rdev;
428 struct scmi_device *scmi_dev = NULL;
429
430 if (name)
431 return __scmi_device_create(np, parent, protocol, name);
432
433 mutex_lock(&scmi_requested_devices_mtx);
434 phead = idr_find(&scmi_requested_devices, protocol);
435 /* Nothing to do. */
436 if (!phead) {
437 mutex_unlock(&scmi_requested_devices_mtx);
438 return NULL;
439 }
440
441 /* Walk the list of requested devices for protocol and create them */
442 list_for_each_entry(rdev, phead, node) {
443 struct scmi_device *sdev;
444
445 sdev = __scmi_device_create(np, parent,
446 rdev->id_table->protocol_id,
447 rdev->id_table->name);
448 /* Report errors and carry on... */
449 if (sdev)
450 scmi_dev = sdev;
451 else
452 pr_err("(%s) Failed to create device for protocol 0x%x (%s)\n",
453 of_node_full_name(parent->of_node),
454 rdev->id_table->protocol_id,
455 rdev->id_table->name);
456 }
457 mutex_unlock(&scmi_requested_devices_mtx);
458
459 return scmi_dev;
460 }
461 EXPORT_SYMBOL_GPL(scmi_device_create);
462
scmi_device_destroy(struct device * parent,int protocol,const char * name)463 void scmi_device_destroy(struct device *parent, int protocol, const char *name)
464 {
465 struct scmi_device *scmi_dev;
466
467 scmi_dev = scmi_child_dev_find(parent, protocol, name);
468 if (scmi_dev)
469 __scmi_device_destroy(scmi_dev);
470 }
471 EXPORT_SYMBOL_GPL(scmi_device_destroy);
472
__scmi_devices_unregister(struct device * dev,void * data)473 static int __scmi_devices_unregister(struct device *dev, void *data)
474 {
475 struct scmi_device *scmi_dev = to_scmi_dev(dev);
476
477 __scmi_device_destroy(scmi_dev);
478 return 0;
479 }
480
scmi_devices_unregister(void)481 static void scmi_devices_unregister(void)
482 {
483 bus_for_each_dev(&scmi_bus_type, NULL, NULL, __scmi_devices_unregister);
484 }
485
scmi_bus_init(void)486 static int __init scmi_bus_init(void)
487 {
488 int retval;
489
490 retval = bus_register(&scmi_bus_type);
491 if (retval)
492 pr_err("SCMI protocol bus register failed (%d)\n", retval);
493
494 pr_info("SCMI protocol bus registered\n");
495
496 return retval;
497 }
498 subsys_initcall(scmi_bus_init);
499
scmi_bus_exit(void)500 static void __exit scmi_bus_exit(void)
501 {
502 /*
503 * Destroy all remaining devices: just in case the drivers were
504 * manually unbound and at first and then the modules unloaded.
505 */
506 scmi_devices_unregister();
507 bus_unregister(&scmi_bus_type);
508 ida_destroy(&scmi_bus_id);
509 }
510 module_exit(scmi_bus_exit);
511
512 MODULE_ALIAS("scmi-core");
513 MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");
514 MODULE_DESCRIPTION("ARM SCMI protocol bus");
515 MODULE_LICENSE("GPL");
516