drivers/firmware/arm_scmi/bus.c

   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 }