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 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                         return id;
  33
  34         return NULL;
  35 }
  36
  37 static int scmi_dev_match(struct device *dev, struct device_driver *drv)
  38 {
  39         struct scmi_driver *scmi_drv = to_scmi_driver(drv);
  40         struct scmi_device *scmi_dev = to_scmi_dev(dev);
  41         const struct scmi_device_id *id;
  42
  43         id = scmi_dev_match_id(scmi_dev, scmi_drv);
  44         if (id)
  45                 return 1;
  46
  47         return 0;
  48 }
  49
  50 static int scmi_protocol_init(int protocol_id, struct scmi_handle *handle)
  51 {
  52         scmi_prot_init_fn_t fn = idr_find(&scmi_protocols, protocol_id);
  53
  54         if (unlikely(!fn))
  55                 return -EINVAL;
  56         return fn(handle);
  57 }
  58
  59 static int scmi_dev_probe(struct device *dev)
  60 {
  61         struct scmi_driver *scmi_drv = to_scmi_driver(dev->driver);
  62         struct scmi_device *scmi_dev = to_scmi_dev(dev);
  63         const struct scmi_device_id *id;
  64         int ret;
  65
  66         id = scmi_dev_match_id(scmi_dev, scmi_drv);
  67         if (!id)
  68                 return -ENODEV;
  69
  70         if (!scmi_dev->handle)
  71                 return -EPROBE_DEFER;
  72
  73         ret = scmi_protocol_init(scmi_dev->protocol_id, scmi_dev->handle);
  74         if (ret)
  75                 return ret;
  76
  77         return scmi_drv->probe(scmi_dev);
  78 }
  79
  80 static int scmi_dev_remove(struct device *dev)
  81 {
  82         struct scmi_driver *scmi_drv = to_scmi_driver(dev->driver);
  83         struct scmi_device *scmi_dev = to_scmi_dev(dev);
  84
  85         if (scmi_drv->remove)
  86                 scmi_drv->remove(scmi_dev);
  87
  88         return 0;
  89 }
  90
  91 static struct bus_type scmi_bus_type = {
  92         .name = "scmi_protocol",
  93         .match = scmi_dev_match,
  94         .probe = scmi_dev_probe,
  95         .remove = scmi_dev_remove,
  96 };
  97
  98 int scmi_driver_register(struct scmi_driver *driver, struct module *owner,
  99                          const char *mod_name)
 100 {
 101         int retval;
 102
 103         driver->driver.bus = &scmi_bus_type;
 104         driver->driver.name = driver->name;
 105         driver->driver.owner = owner;
 106         driver->driver.mod_name = mod_name;
 107
 108         retval = driver_register(&driver->driver);
 109         if (!retval)
 110                 pr_debug("registered new scmi driver %s\n", driver->name);
 111
 112         return retval;
 113 }
 114 EXPORT_SYMBOL_GPL(scmi_driver_register);
 115
 116 void scmi_driver_unregister(struct scmi_driver *driver)
 117 {
 118         driver_unregister(&driver->driver);
 119 }
 120 EXPORT_SYMBOL_GPL(scmi_driver_unregister);
 121
 122 static void scmi_device_release(struct device *dev)
 123 {
 124         kfree(to_scmi_dev(dev));
 125 }
 126
 127 struct scmi_device *
 128 scmi_device_create(struct device_node *np, struct device *parent, int protocol)
 129 {
 130         int id, retval;
 131         struct scmi_device *scmi_dev;
 132
 133         scmi_dev = kzalloc(sizeof(*scmi_dev), GFP_KERNEL);
 134         if (!scmi_dev)
 135                 return NULL;
 136
 137         id = ida_simple_get(&scmi_bus_id, 1, 0, GFP_KERNEL);
 138         if (id < 0)
 139                 goto free_mem;
 140
 141         scmi_dev->id = id;
 142         scmi_dev->protocol_id = protocol;
 143         scmi_dev->dev.parent = parent;
 144         scmi_dev->dev.of_node = np;
 145         scmi_dev->dev.bus = &scmi_bus_type;
 146         scmi_dev->dev.release = scmi_device_release;
 147         dev_set_name(&scmi_dev->dev, "scmi_dev.%d", id);
 148
 149         retval = device_register(&scmi_dev->dev);
 150         if (retval)
 151                 goto put_dev;
 152
 153         return scmi_dev;
 154 put_dev:
 155         put_device(&scmi_dev->dev);
 156         ida_simple_remove(&scmi_bus_id, id);
 157 free_mem:
 158         kfree(scmi_dev);
 159         return NULL;
 160 }
 161
 162 void scmi_device_destroy(struct scmi_device *scmi_dev)
 163 {
 164         scmi_handle_put(scmi_dev->handle);
 165         ida_simple_remove(&scmi_bus_id, scmi_dev->id);
 166         device_unregister(&scmi_dev->dev);
 167 }
 168
 169 void scmi_set_handle(struct scmi_device *scmi_dev)
 170 {
 171         scmi_dev->handle = scmi_handle_get(&scmi_dev->dev);
 172 }
 173
 174 int scmi_protocol_register(int protocol_id, scmi_prot_init_fn_t fn)
 175 {
 176         int ret;
 177
 178         spin_lock(&protocol_lock);
 179         ret = idr_alloc(&scmi_protocols, fn, protocol_id, protocol_id + 1,
 180                         GFP_ATOMIC);
 181         spin_unlock(&protocol_lock);
 182         if (ret != protocol_id)
 183                 pr_err("unable to allocate SCMI idr slot, err %d\n", ret);
 184
 185         return ret;
 186 }
 187 EXPORT_SYMBOL_GPL(scmi_protocol_register);
 188
 189 void scmi_protocol_unregister(int protocol_id)
 190 {
 191         spin_lock(&protocol_lock);
 192         idr_remove(&scmi_protocols, protocol_id);
 193         spin_unlock(&protocol_lock);
 194 }
 195 EXPORT_SYMBOL_GPL(scmi_protocol_unregister);
 196
 197 static int __scmi_devices_unregister(struct device *dev, void *data)
 198 {
 199         struct scmi_device *scmi_dev = to_scmi_dev(dev);
 200
 201         scmi_device_destroy(scmi_dev);
 202         return 0;
 203 }
 204
 205 static void scmi_devices_unregister(void)
 206 {
 207         bus_for_each_dev(&scmi_bus_type, NULL, NULL, __scmi_devices_unregister);
 208 }
 209
 210 static int __init scmi_bus_init(void)
 211 {
 212         int retval;
 213
 214         retval = bus_register(&scmi_bus_type);
 215         if (retval)
 216                 pr_err("scmi protocol bus register failed (%d)\n", retval);
 217
 218         return retval;
 219 }
 220 subsys_initcall(scmi_bus_init);
 221
 222 static void __exit scmi_bus_exit(void)
 223 {
 224         scmi_devices_unregister();
 225         bus_unregister(&scmi_bus_type);
 226         ida_destroy(&scmi_bus_id);
 227 }
 228 module_exit(scmi_bus_exit);