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 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 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 */ 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 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 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 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 */ 154static 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 189static const struct scmi_device_id * 190scmi_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 208static 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 221static 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 230static 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 246static 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 257static 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 266struct 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}; 272EXPORT_SYMBOL_GPL(scmi_bus_type); 273 274int 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} 297EXPORT_SYMBOL_GPL(scmi_driver_register); 298 299void scmi_driver_unregister(struct scmi_driver *driver) 300{ 301 driver_unregister(&driver->driver); 302 scmi_protocol_device_unrequest(driver->id_table); 303} 304EXPORT_SYMBOL_GPL(scmi_driver_unregister); 305 306static void scmi_device_release(struct device *dev) 307{ 308 kfree(to_scmi_dev(dev)); 309} 310 311static 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 326static struct scmi_device * 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; 392put_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 */ 422struct 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} 461EXPORT_SYMBOL_GPL(scmi_device_create); 462 463void 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} 471EXPORT_SYMBOL_GPL(scmi_device_destroy); 472 473static 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 481static void scmi_devices_unregister(void) 482{ 483 bus_for_each_dev(&scmi_bus_type, NULL, NULL, __scmi_devices_unregister); 484} 485 486static 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} 498subsys_initcall(scmi_bus_init); 499 500static 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} 510module_exit(scmi_bus_exit); 511 512MODULE_ALIAS("scmi-core"); 513MODULE_AUTHOR("Sudeep Holla <sudeep.holla@arm.com>"); 514MODULE_DESCRIPTION("ARM SCMI protocol bus"); 515MODULE_LICENSE("GPL"); 516