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 * 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 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 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 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 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 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 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 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 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 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 166 static void scmi_device_release(struct device *dev) 167 { 168 kfree(to_scmi_dev(dev)); 169 } 170 171 struct scmi_device * 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 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 223 void scmi_set_handle(struct scmi_device *scmi_dev) 224 { 225 scmi_dev->handle = scmi_handle_get(&scmi_dev->dev); 226 } 227 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 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 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 278 static void scmi_devices_unregister(void) 279 { 280 bus_for_each_dev(&scmi_bus_type, NULL, NULL, __scmi_devices_unregister); 281 } 282 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 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