537 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * System Control and Management Interface (SCMI) Message Protocol bus layer4 *5 * Copyright (C) 2018-2021 ARM Ltd.6 */7 8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt9 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 20BLOCKING_NOTIFIER_HEAD(scmi_requested_devices_nh);21EXPORT_SYMBOL_GPL(scmi_requested_devices_nh);22 23static DEFINE_IDA(scmi_bus_id);24 25static DEFINE_IDR(scmi_requested_devices);26/* Protect access to scmi_requested_devices */27static DEFINE_MUTEX(scmi_requested_devices_mtx);28 29struct 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 */35static atomic_t scmi_syspower_registered = ATOMIC_INIT(0);36 37/**38 * scmi_protocol_device_request - Helper to request a device39 *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 the43 * @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 table47 * @scmi_requested_devices and then the requested device is advertised to any48 * registered party via the @scmi_requested_devices_nh notification chain.49 *50 * Return: 0 on Success51 */52static 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 search71 * 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 new96 * 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 the107 * related protocol list, eventually creating such head if not already108 * 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 133out: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 144static int scmi_protocol_table_register(const struct scmi_device_id *id_table)145{146 int ret = 0;147 const struct scmi_device_id *entry;148 149 for (entry = id_table; entry->name && ret == 0; entry++)150 ret = scmi_protocol_device_request(entry);151 152 return ret;153}154 155/**156 * scmi_protocol_device_unrequest - Helper to unrequest a device157 *158 * @id_table: A protocol/name pair descriptor for the device to be unrequested.159 *160 * The unrequested device, described by the provided id_table, is at first161 * removed from the IDR @scmi_requested_devices and then the removal is162 * advertised to any registered party via the @scmi_requested_devices_nh163 * notification chain.164 */165static void scmi_protocol_device_unrequest(const struct scmi_device_id *id_table)166{167 struct list_head *phead;168 169 pr_debug("Unrequesting SCMI device (%s) for protocol %x\n",170 id_table->name, id_table->protocol_id);171 172 mutex_lock(&scmi_requested_devices_mtx);173 phead = idr_find(&scmi_requested_devices, id_table->protocol_id);174 if (phead) {175 struct scmi_requested_dev *victim, *tmp;176 177 list_for_each_entry_safe(victim, tmp, phead, node) {178 if (!strcmp(victim->id_table->name, id_table->name)) {179 list_del(&victim->node);180 181 mutex_unlock(&scmi_requested_devices_mtx);182 blocking_notifier_call_chain(&scmi_requested_devices_nh,183 SCMI_BUS_NOTIFY_DEVICE_UNREQUEST,184 (void *)victim->id_table);185 kfree(victim);186 mutex_lock(&scmi_requested_devices_mtx);187 break;188 }189 }190 191 if (list_empty(phead)) {192 idr_remove(&scmi_requested_devices,193 id_table->protocol_id);194 kfree(phead);195 }196 }197 mutex_unlock(&scmi_requested_devices_mtx);198}199 200static void201scmi_protocol_table_unregister(const struct scmi_device_id *id_table)202{203 const struct scmi_device_id *entry;204 205 for (entry = id_table; entry->name; entry++)206 scmi_protocol_device_unrequest(entry);207}208 209static const struct scmi_device_id *210scmi_dev_match_id(struct scmi_device *scmi_dev, const struct scmi_driver *scmi_drv)211{212 const struct scmi_device_id *id = scmi_drv->id_table;213 214 if (!id)215 return NULL;216 217 for (; id->protocol_id; id++)218 if (id->protocol_id == scmi_dev->protocol_id) {219 if (!id->name)220 return id;221 else if (!strcmp(id->name, scmi_dev->name))222 return id;223 }224 225 return NULL;226}227 228static int scmi_dev_match(struct device *dev, const struct device_driver *drv)229{230 const struct scmi_driver *scmi_drv = to_scmi_driver(drv);231 struct scmi_device *scmi_dev = to_scmi_dev(dev);232 const struct scmi_device_id *id;233 234 id = scmi_dev_match_id(scmi_dev, scmi_drv);235 if (id)236 return 1;237 238 return 0;239}240 241static int scmi_match_by_id_table(struct device *dev, void *data)242{243 struct scmi_device *sdev = to_scmi_dev(dev);244 struct scmi_device_id *id_table = data;245 246 return sdev->protocol_id == id_table->protocol_id &&247 (id_table->name && !strcmp(sdev->name, id_table->name));248}249 250static struct scmi_device *scmi_child_dev_find(struct device *parent,251 int prot_id, const char *name)252{253 struct scmi_device_id id_table;254 struct device *dev;255 256 id_table.protocol_id = prot_id;257 id_table.name = name;258 259 dev = device_find_child(parent, &id_table, scmi_match_by_id_table);260 if (!dev)261 return NULL;262 263 return to_scmi_dev(dev);264}265 266static int scmi_dev_probe(struct device *dev)267{268 struct scmi_driver *scmi_drv = to_scmi_driver(dev->driver);269 struct scmi_device *scmi_dev = to_scmi_dev(dev);270 271 if (!scmi_dev->handle)272 return -EPROBE_DEFER;273 274 return scmi_drv->probe(scmi_dev);275}276 277static void scmi_dev_remove(struct device *dev)278{279 struct scmi_driver *scmi_drv = to_scmi_driver(dev->driver);280 struct scmi_device *scmi_dev = to_scmi_dev(dev);281 282 if (scmi_drv->remove)283 scmi_drv->remove(scmi_dev);284}285 286const struct bus_type scmi_bus_type = {287 .name = "scmi_protocol",288 .match = scmi_dev_match,289 .probe = scmi_dev_probe,290 .remove = scmi_dev_remove,291};292EXPORT_SYMBOL_GPL(scmi_bus_type);293 294int scmi_driver_register(struct scmi_driver *driver, struct module *owner,295 const char *mod_name)296{297 int retval;298 299 if (!driver->probe)300 return -EINVAL;301 302 retval = scmi_protocol_table_register(driver->id_table);303 if (retval)304 return retval;305 306 driver->driver.bus = &scmi_bus_type;307 driver->driver.name = driver->name;308 driver->driver.owner = owner;309 driver->driver.mod_name = mod_name;310 311 retval = driver_register(&driver->driver);312 if (!retval)313 pr_debug("Registered new scmi driver %s\n", driver->name);314 315 return retval;316}317EXPORT_SYMBOL_GPL(scmi_driver_register);318 319void scmi_driver_unregister(struct scmi_driver *driver)320{321 driver_unregister(&driver->driver);322 scmi_protocol_table_unregister(driver->id_table);323}324EXPORT_SYMBOL_GPL(scmi_driver_unregister);325 326static void scmi_device_release(struct device *dev)327{328 struct scmi_device *scmi_dev = to_scmi_dev(dev);329 330 kfree_const(scmi_dev->name);331 kfree(scmi_dev);332}333 334static void __scmi_device_destroy(struct scmi_device *scmi_dev)335{336 pr_debug("(%s) Destroying SCMI device '%s' for protocol 0x%x (%s)\n",337 of_node_full_name(scmi_dev->dev.parent->of_node),338 dev_name(&scmi_dev->dev), scmi_dev->protocol_id,339 scmi_dev->name);340 341 if (scmi_dev->protocol_id == SCMI_PROTOCOL_SYSTEM)342 atomic_set(&scmi_syspower_registered, 0);343 344 ida_free(&scmi_bus_id, scmi_dev->id);345 device_unregister(&scmi_dev->dev);346}347 348static struct scmi_device *349__scmi_device_create(struct device_node *np, struct device *parent,350 int protocol, const char *name)351{352 int id, retval;353 struct scmi_device *scmi_dev;354 355 /*356 * If the same protocol/name device already exist under the same parent357 * (i.e. SCMI instance) just return the existent device.358 * This avoids any race between the SCMI driver, creating devices for359 * each DT defined protocol at probe time, and the concurrent360 * registration of SCMI drivers.361 */362 scmi_dev = scmi_child_dev_find(parent, protocol, name);363 if (scmi_dev)364 return scmi_dev;365 366 /*367 * Ignore any possible subsequent failures while creating the device368 * since we are doomed anyway at that point; not using a mutex which369 * spans across this whole function to keep things simple and to avoid370 * to serialize all the __scmi_device_create calls across possibly371 * different SCMI server instances (parent)372 */373 if (protocol == SCMI_PROTOCOL_SYSTEM &&374 atomic_cmpxchg(&scmi_syspower_registered, 0, 1)) {375 dev_warn(parent,376 "SCMI SystemPower protocol device must be unique !\n");377 return NULL;378 }379 380 scmi_dev = kzalloc(sizeof(*scmi_dev), GFP_KERNEL);381 if (!scmi_dev)382 return NULL;383 384 scmi_dev->name = kstrdup_const(name ?: "unknown", GFP_KERNEL);385 if (!scmi_dev->name) {386 kfree(scmi_dev);387 return NULL;388 }389 390 id = ida_alloc_min(&scmi_bus_id, 1, GFP_KERNEL);391 if (id < 0) {392 kfree_const(scmi_dev->name);393 kfree(scmi_dev);394 return NULL;395 }396 397 scmi_dev->id = id;398 scmi_dev->protocol_id = protocol;399 scmi_dev->dev.parent = parent;400 device_set_node(&scmi_dev->dev, of_fwnode_handle(np));401 scmi_dev->dev.bus = &scmi_bus_type;402 scmi_dev->dev.release = scmi_device_release;403 dev_set_name(&scmi_dev->dev, "scmi_dev.%d", id);404 405 retval = device_register(&scmi_dev->dev);406 if (retval)407 goto put_dev;408 409 pr_debug("(%s) Created SCMI device '%s' for protocol 0x%x (%s)\n",410 of_node_full_name(parent->of_node),411 dev_name(&scmi_dev->dev), protocol, name);412 413 return scmi_dev;414put_dev:415 put_device(&scmi_dev->dev);416 ida_free(&scmi_bus_id, id);417 return NULL;418}419 420/**421 * scmi_device_create - A method to create one or more SCMI devices422 *423 * @np: A reference to the device node to use for the new device(s)424 * @parent: The parent device to use identifying a specific SCMI instance425 * @protocol: The SCMI protocol to be associated with this device426 * @name: The requested-name of the device to be created; this is optional427 * and if no @name is provided, all the devices currently known to428 * be requested on the SCMI bus for @protocol will be created.429 *430 * This method can be invoked to create a single well-defined device (like431 * a transport device or a device requested by an SCMI driver loaded after432 * the core SCMI stack has been probed), or to create all the devices currently433 * known to have been requested by the loaded SCMI drivers for a specific434 * protocol (typically during SCMI core protocol enumeration at probe time).435 *436 * Return: The created device (or one of them if @name was NOT provided and437 * multiple devices were created) or NULL if no device was created;438 * note that NULL indicates an error ONLY in case a specific @name439 * was provided: when @name param was not provided, a number of devices440 * could have been potentially created for a whole protocol, unless no441 * device was found to have been requested for that specific protocol.442 */443struct scmi_device *scmi_device_create(struct device_node *np,444 struct device *parent, int protocol,445 const char *name)446{447 struct list_head *phead;448 struct scmi_requested_dev *rdev;449 struct scmi_device *scmi_dev = NULL;450 451 if (name)452 return __scmi_device_create(np, parent, protocol, name);453 454 mutex_lock(&scmi_requested_devices_mtx);455 phead = idr_find(&scmi_requested_devices, protocol);456 /* Nothing to do. */457 if (!phead) {458 mutex_unlock(&scmi_requested_devices_mtx);459 return NULL;460 }461 462 /* Walk the list of requested devices for protocol and create them */463 list_for_each_entry(rdev, phead, node) {464 struct scmi_device *sdev;465 466 sdev = __scmi_device_create(np, parent,467 rdev->id_table->protocol_id,468 rdev->id_table->name);469 /* Report errors and carry on... */470 if (sdev)471 scmi_dev = sdev;472 else473 pr_err("(%s) Failed to create device for protocol 0x%x (%s)\n",474 of_node_full_name(parent->of_node),475 rdev->id_table->protocol_id,476 rdev->id_table->name);477 }478 mutex_unlock(&scmi_requested_devices_mtx);479 480 return scmi_dev;481}482EXPORT_SYMBOL_GPL(scmi_device_create);483 484void scmi_device_destroy(struct device *parent, int protocol, const char *name)485{486 struct scmi_device *scmi_dev;487 488 scmi_dev = scmi_child_dev_find(parent, protocol, name);489 if (scmi_dev)490 __scmi_device_destroy(scmi_dev);491}492EXPORT_SYMBOL_GPL(scmi_device_destroy);493 494static int __scmi_devices_unregister(struct device *dev, void *data)495{496 struct scmi_device *scmi_dev = to_scmi_dev(dev);497 498 __scmi_device_destroy(scmi_dev);499 return 0;500}501 502static void scmi_devices_unregister(void)503{504 bus_for_each_dev(&scmi_bus_type, NULL, NULL, __scmi_devices_unregister);505}506 507static int __init scmi_bus_init(void)508{509 int retval;510 511 retval = bus_register(&scmi_bus_type);512 if (retval)513 pr_err("SCMI protocol bus register failed (%d)\n", retval);514 515 pr_info("SCMI protocol bus registered\n");516 517 return retval;518}519subsys_initcall(scmi_bus_init);520 521static void __exit scmi_bus_exit(void)522{523 /*524 * Destroy all remaining devices: just in case the drivers were525 * manually unbound and at first and then the modules unloaded.526 */527 scmi_devices_unregister();528 bus_unregister(&scmi_bus_type);529 ida_destroy(&scmi_bus_id);530}531module_exit(scmi_bus_exit);532 533MODULE_ALIAS("scmi-core");534MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>");535MODULE_DESCRIPTION("ARM SCMI protocol bus");536MODULE_LICENSE("GPL");537